@things-factory/ai-assistant 10.1.208 → 10.1.212

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/ai-assistant",
-  "version": "10.1.208",
+  "version": "10.1.212",
   "main": "dist-server/index.js",
   "things-factory": true,
   "author": "heartyoh",
@@ -35,12 +35,12 @@
     "@operato/shell": "^10.29.39",
     "@operato/styles": "^10.0.0",
     "@operato/utils": "^10.29.39",
-    "@things-factory/ai-client-base": "^10.1.208",
+    "@things-factory/ai-client-base": "^10.1.212",
     "@things-factory/apptool-base": "^10.1.208",
-    "@things-factory/attachment-base": "^10.1.208",
-    "@things-factory/auth-base": "^10.1.208",
+    "@things-factory/attachment-base": "^10.1.212",
+    "@things-factory/auth-base": "^10.1.212",
     "@things-factory/env": "^10.1.149",
-    "@things-factory/setting-base": "^10.1.208",
+    "@things-factory/setting-base": "^10.1.212",
     "@things-factory/shell": "^10.1.208",
     "dompurify": "^3.0.0",
     "exceljs": "4.2.0",
@@ -55,5 +55,5 @@
     "copyfiles": "^2.4.1",
     "rimraf": "^5.0.0"
   },
-  "gitHead": "ffc1ceaa9471b9f4a9b86f46c3021f2fed72d17d"
+  "gitHead": "1e1cdb79fca2915580429af451b6cf1dae653a93"
 }

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, FINISH_RULE, NEXT_REQUEST_RULE, conversationPrompt, isPersonRequest, 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/screen-rules.test.ts

@@ -1,7 +1,7 @@
 /*
  * The rules every conversation follows (operato-application design/ai/screen-pattern.md §4).
  */
-import { ABSENCE_RULE, FINISH_RULE, NEXT_REQUEST_RULE, conversationPrompt, isPersonRequest, 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', () => {
@@ -67,5 +67,11 @@ describe('the prompt every conversation gets', () => {
     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

@@ -26,12 +26,21 @@ export const FINISH_RULE =
   '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>": ` +
+  `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. ' +
@@ -39,7 +48,7 @@ export const NEXT_REQUEST_RULE =
 
 /** A mode's persona with the rules every conversation follows. */
 export function conversationPrompt(modePrompt: string): string {
-  return [modePrompt.trim(), ABSENCE_RULE, FINISH_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. */

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-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))

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

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