@things-factory/ai-assistant 10.1.207 → 10.1.210

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

@@ -2,7 +2,7 @@
  * Data entry from material (design/ai/data-entry.md) - the rules a row passes, what the tool hands back,
  * and what the server asks again before it writes.
  */
-import { offsetAt, zonedDateTimes, clearEntryTargets, declareEntryTarget, entryDoorOf, entryToolName, entryTotals, lineHas, normalizeEntryRows, printedTotalOf, verifyRowsAgainstSources, writtenForms, type EntryTarget } from './entry-target'
+import { readFieldValue, recordIdOfKey, resolveReferences, offsetAt, zonedDateTimes, clearEntryTargets, declareEntryTarget, entryDoorOf, entryToolName, entryTotals, lineHas, normalizeEntryRows, printedTotalOf, verifyRowsAgainstSources, writtenForms, type EntryTarget } from './entry-target'
 import { entryCategoryOf, proposeEntries } from './entry-tools'
 import { applyEntryProposal, entryProposalAnswered, findEntryProposal, type EntryApplyDeps } from './entry-apply'
 import { modeToolCategories } from '../assistant-mode/resolve'
@@ -410,3 +410,67 @@ describe("a moment is the domain's wall time", () => {
     expect(result.rows[0].values.startTime).toBe('2026-10-01T08:30:00+09:00')
   })
 })
+
+/*
+ * 2026-10-23: an office link card took `tax-invoice:<uuid>` - the key the link evidence and the open record show - and
+ * looked it up as an approval number. A reference that names a record of an axis reads that axis's key as its id.
+ */
+describe('a reference names the record the model was shown', () => {
+  const ID = 'fe0e8503-ec5f-4da4-9c07-2d342c93d498'
+  const invoice = {
+    name: 'invoice',
+    type: 'reference' as const,
+    axis: 'tax-invoice',
+    reference: {
+      query: 'query ($text: String) { invoices(text: $text) { items { id approvalNo } } }',
+      variables: (text: string) => ({ text }),
+      recordsOf: (data: any, text: string) => (data?.invoices?.items ?? []).filter((one: any) => one.id === text || one.approvalNo === text)
+    }
+  }
+  const asked: string[] = []
+  const run = async (_query: string, variables: any) => {
+    asked.push(variables.text)
+    return { data: { invoices: { items: [{ id: ID, approvalNo: '20260120-10260120-17151515' }] } } }
+  }
+  const resolved = async (text: string, field: any = invoice) => {
+    const [row] = await resolveReferences([field], [{ values: { invoice: { text } }, issues: [] as any[] }], run)
+    return row.issues.length ? row.issues[0].code : row.values.invoice.id
+  }
+  beforeEach(() => (asked.length = 0))
+
+  it('★ the key `<axis>:<uuid>`, the bare uuid and the record\'s own words all find it', async () => {
+    expect(await resolved(`tax-invoice:${ID}`)).toBe(ID)
+    expect(asked).toEqual([ID])
+    expect(await resolved(ID)).toBe(ID)
+    expect(await resolved('20260120-10260120-17151515')).toBe(ID)
+  })
+
+  it('★ the key of a record of another axis is not this record, whatever its uuid', async () => {
+    expect(await resolved(`cash-transaction:${ID}`)).toBe('reference-not-found')
+  })
+
+  it('a reference with no axis reads what was written, as before', async () => {
+    const { axis, ...plain } = invoice
+    expect(await resolved(`tax-invoice:${ID}`, plain)).toBe('reference-not-found')
+    expect(asked).toEqual([`tax-invoice:${ID}`])
+  })
+
+  it('★ a field that holds a record\'s id reads its key as the id - one axis or any of several', () => {
+    const question = { name: 'questionId', type: 'string' as const, axis: 'strategy-question' }
+    expect(readFieldValue(question, ` strategy-question:${ID} `)).toEqual({ read: ID })
+    expect(readFieldValue(question, `initiative:${ID}`)).toEqual({ read: `initiative:${ID}` })
+    const owner = { name: 'ownerId', type: 'string' as const, axis: ['strategy-question', 'initiative'] }
+    expect(readFieldValue(owner, `initiative:${ID}`)).toEqual({ read: ID })
+    expect(readFieldValue({ name: 'note', type: 'string' }, `initiative:${ID}`)).toEqual({ read: `initiative:${ID}` })
+    /* A model that hands a resolved reference the key, not the id. */
+    expect(readFieldValue(invoice, { id: `tax-invoice:${ID}` })).toEqual({ read: { id: ID } })
+  })
+
+  it('a key names an id only when it is one', () => {
+    expect(recordIdOfKey('contract', `contract:${ID}`)).toBe(ID)
+    expect(recordIdOfKey('contract', ID.toUpperCase())).toBe(ID.toUpperCase())
+    expect(recordIdOfKey('contract', 'contract:H2026012')).toBeUndefined()
+    expect(recordIdOfKey('contract', 'H2026012')).toBeUndefined()
+    expect(recordIdOfKey('contract', `contract-round:${ID}`)).toBeUndefined()
+  })
+})

package/server/service/data-entry/entry-target.ts

@@ -36,6 +36,14 @@ export interface EntryField {
    * taken; none or several keep the row out and say so - the server never picks among several.
    */
   reference?: EntryReference
+  /**
+   * The axis of the record the field names (`tax-invoice`, `contract`) - several when it may name a record of each - for a
+   * record the model is shown by its key: an open record's anchor and an application's link evidence write
+   * `<axis>:<id>`. The key is read as the id it names, so what the model was shown is what it may write (2026-10-23: a
+   * card took `tax-invoice:<uuid>` from the evidence, looked it up as an approval number and found nothing). A reference
+   * reads it before its query runs; a string field holding an id reads it as the id.
+   */
+  axis?: string | readonly string[]
 }
 
 export interface EntryReference {
@@ -46,6 +54,22 @@ export interface EntryReference {
   recordsOf(data: any, text: string): { id: string; label?: string }[]
 }
 
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+
+/**
+ * The id a record's key names - `<axis>:<uuid>` as an anchor writes it, or the uuid alone. Nothing for a word, or for
+ * the key of a record of another axis: that one is not this record, whatever its uuid.
+ */
+export function recordIdOfKey(axis: string | readonly string[], text: string): string | undefined {
+  const value = String(text ?? '').trim()
+  const prefix = (typeof axis === 'string' ? [axis] : axis).map(one => `${one}:`).find(one => value.startsWith(one))
+  const id = prefix ? value.slice(prefix.length) : value
+  return UUID.test(id) ? id : undefined
+}
+
+/** What the model wrote for a field that names a record - the id, when it wrote the record's key. */
+const shownId = (field: EntryField, text: string): string => (field.axis && recordIdOfKey(field.axis, text)) || text
+
 /** A resolved reference, as a row keeps it. */
 export interface ReferenceValue {
   id: string
@@ -116,6 +140,12 @@ export interface EntryEvent {
 export interface EntryTarget {
   /** `<app>.<record>` - `office.expense-line`. */
   key: string
+  /**
+   * The records the card is about besides its own (the axes of `subject` anchors) - a link card is about the deposit,
+   * the invoice and the round it joins. On those records' screens its propose tool is put in front (ADR-0061 decision
+   * 9); asked to link a deposit from its 360, the model found the invoice and never opened the card (2026-10-24).
+   */
+  axes?: string[]
   /** i18n key of the record's name on the card. */
   labelKey: string
   /** What one row is, for the model. */
@@ -381,11 +411,11 @@ export function readFieldValue(field: EntryField, value: unknown): { read?: unkn
       return field.values!.includes(String(value).trim()) ? { read: String(value).trim() } : { code: 'not-in-list' }
     case 'reference':
       /* Resolved already ({ id }), or a name to look up ({ text }) - resolveReferences settles the second. */
-      if (value && typeof value === 'object' && typeof (value as any).id === 'string') return { read: { id: (value as any).id, ...((value as any).label ? { label: String((value as any).label) } : {}) } }
+      if (value && typeof value === 'object' && typeof (value as any).id === 'string') return { read: { id: shownId(field, (value as any).id), ...((value as any).label ? { label: String((value as any).label) } : {}) } }
       if (value && typeof value === 'object' && typeof (value as any).text === 'string') return { read: { text: (value as any).text } }
       return typeof value === 'string' || typeof value === 'number' ? { read: { text: String(value).trim() } } : { code: 'not-a-reference' }
     default:
-      return { read: String(value).trim() }
+      return { read: shownId(field, String(value).trim()) }
   }
 }
 
@@ -651,11 +681,12 @@ export async function resolveReferences<T extends { values: Record<string, unkno
     for (const field of references) {
       const value: any = row.values[field.name]
       if (!value || typeof value !== 'object' || typeof value.text !== 'string') continue
-      const key = `${field.name}\u0000${value.text}`
+      const text = shownId(field, value.text)
+      const key = `${field.name}\u0000${text}`
       if (!asked.has(key)) {
         try {
-          const answer = await run(field.reference!.query, field.reference!.variables(value.text))
-          asked.set(key, answer.errors?.length ? new Error(answer.errors[0].message) : field.reference!.recordsOf(answer.data, value.text) ?? [])
+          const answer = await run(field.reference!.query, field.reference!.variables(text))
+          asked.set(key, answer.errors?.length ? new Error(answer.errors[0].message) : field.reference!.recordsOf(answer.data, text) ?? [])
         } catch (error: any) {
           asked.set(key, error instanceof Error ? error : new Error(String(error)))
         }

package/server/service/data-entry/entry-tools.ts

@@ -153,7 +153,7 @@ function changeSpecs(target: EntryTarget, run: (context: any) => GraphqlRunner):
       doors: [...new Set([rootFieldOf(update.mutation, 'mutation'), readDoor, ...referenceDoorsOf(changeableFields(target))])],
       description:
         `Propose changes to existing records: ${target.description} ` +
-        'Name each record by ref: "current" (the one on screen), "selected" (every row selected on screen) or an id a find tool returned. ' +
+        'Name each record by ref: "current" (the one on screen), "selected" (every row selected on screen), the id a list read or a find tool returned, or the record\'s key (`<kind>:<id>`) as you were shown it - nothing need be selected to change rows a read found. ' +
         'The server reads each record, and the card shows what it holds now and what it becomes; nothing changes until the person presses it.',
       schema: {
         type: 'object',
@@ -163,7 +163,7 @@ function changeSpecs(target: EntryTarget, run: (context: any) => GraphqlRunner):
             items: {
               type: 'object',
               properties: {
-                ref: { type: 'string', description: '"current", "selected", or a record id from a find tool - never a guessed id.' },
+                ref: { type: 'string', description: '"current", "selected", a record id from a list read or a find tool, or the record\'s key as shown - never a guessed id.' },
                 values: { type: 'object', description: 'Only the fields that change, with their new values.', properties: Object.fromEntries(changeableFields(target).map(field => [field.name, fieldSchema(field)])) }
               },
               required: ['ref', 'values']

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

@@ -13,6 +13,7 @@ import {
   changeToolName,
   findToolName,
   readFieldValue,
+  recordIdOfKey,
   resolveReferences,
   zonedDateTimes,
   sameFieldValue,
@@ -52,7 +53,8 @@ export function changeableFields(target: EntryTarget): EntryField[] {
 /**
  * The records the changes name. `current` is the record on screen, `selected` every row selected there -
  * both from the surface's host context, which is **not trusted**: an id from it is only a candidate, read
- * through the application before anything is shown. Any other ref is an id, from the find tool.
+ * through the application before anything is shown. Any other ref is an id, from the find tool, or the key the record
+ * was shown by.
  */
 export function resolveChangeRefs(
   targetKey: string,
@@ -74,7 +76,8 @@ export function resolveChangeRefs(
       if (ids.length) for (const id of ids) picked.push({ id, via: 'selected', values })
       else unresolved.push('selected')
     } else if (ref) {
-      picked.push({ id: ref, via: 'id', values })
+      /* An open record's key - `contract-round:<id>` for `office.contract-round` - names the record of this target's axis. */
+      picked.push({ id: recordIdOfKey(targetKey.split('.').pop()!, ref) ?? ref, via: 'id', values })
     } else {
       unresolved.push('no-ref')
     }
@@ -143,7 +146,7 @@ export async function proposeChanges(target: EntryTarget, args: any, context: an
       message:
         unresolved[0] === 'current' || unresolved[0] === 'selected'
           ? `the screen names no ${unresolved[0] === 'current' ? 'record' : 'selected rows'} of this kind. Ask the person which record, or call ${findToolName(target.key)}.`
-          : `name each record: ref "current", "selected", or an id from ${findToolName(target.key)}. Never guess an id.`
+          : `name each record: ref "current", "selected", or an id a list read or ${findToolName(target.key)} returned. Never guess an id.`
     }
   }
   let records: Map<string, EntryRecord>

package/server/service/data-read/list-missing.test.ts

@@ -0,0 +1,49 @@
+/*
+ * A list read takes what a row is missing, as its screen's filters say it (2026-10-24) - asked to fill the bank lines'
+ * unregistered parties, the model had no condition for "unregistered" and searched the asker's own name.
+ */
+import { listReadTarget } from './list-read'
+import { filtersOf, readCriteria } from './read-target'
+
+const lines = listReadTarget({
+  key: 'office.cash-transaction',
+  title: 'menu.cash-transaction-list',
+  name: 'bank lines',
+  listQuery: 'transactions',
+  selection: 'id amount counterpartyName',
+  columns: [{ name: 'amount', type: 'number' }],
+  missing: [
+    {
+      name: 'counterparty',
+      description: 'a party name and no registered counterparty',
+      filters: [
+        { name: 'counterpartyId', operator: 'is_null', value: true },
+        { name: 'counterpartyName', operator: 'is_not_null', value: true }
+      ]
+    },
+    { name: 'account', description: 'no account subject', filters: [{ name: 'accountId', operator: 'is_null', value: true }] }
+  ]
+})
+
+describe('what a row is missing', () => {
+  it('★ the condition asks with the screen\'s own filters', () => {
+    const { criteria } = readCriteria(lines, { missing: 'counterparty' })
+    expect(filtersOf(lines, criteria)).toEqual([
+      { name: 'counterpartyId', operator: 'is_null', value: true },
+      { name: 'counterpartyName', operator: 'is_not_null', value: true }
+    ])
+    expect(filtersOf(lines, readCriteria(lines, { missing: 'account' }).criteria)).toEqual([{ name: 'accountId', operator: 'is_null', value: true }])
+  })
+
+  it('★ the model is told each thing a row may miss, and nothing else is taken', () => {
+    const missing = lines.criteria.find(one => one.name === 'missing')!
+    expect(missing.values).toEqual(['counterparty', 'account'])
+    expect(missing.description).toMatch(/counterparty - a party name and no registered counterparty/)
+    expect(readCriteria(lines, { missing: 'phone' }).refused).toEqual([{ name: 'missing', code: 'not-in-list' }])
+  })
+
+  it('a list that declares nothing missing has no such condition', () => {
+    const { missing, ...plain } = { ...(lines as any), missing: undefined }
+    expect(listReadTarget({ key: 'office.x', title: 't', name: 'x', listQuery: 'xs', selection: 'id', columns: [] }).criteria.some(one => one.name === 'missing')).toBe(false)
+  })
+})

package/server/service/data-read/list-read.ts

@@ -33,6 +33,12 @@ export interface ListRead {
   route?: string
   /** The route has a URL-bound grid. Otherwise conditions are disclosed as not applied on its screen card. */
   screenQuery?: boolean
+  /**
+   * What a row may be missing - the screen's own "no counterparty", "no account subject" filters - the `missing`
+   * condition. Asked to fill the bank lines' unregistered parties, the model had no way to say "unregistered" and
+   * searched the asker's own name (2026-10-24).
+   */
+  missing?: { name: string; description: string; filters: ReadFilter[] }[]
 }
 
 /** The money column a minimum or maximum amount means - `amount` when there is one, else the first summed column. */
@@ -62,6 +68,18 @@ export function listReadTarget(list: ListRead): ReadTarget {
     ...(list.status
       ? [{ name: 'status', type: 'enum', values: list.status.values, labelKey: 'ai-assistant.read.status', filter: (v: any) => ({ name: list.status!.field, operator: 'eq', value: v }) }]
       : []),
+    ...(list.missing?.length
+      ? [
+          {
+            name: 'missing',
+            type: 'enum',
+            values: list.missing.map(one => one.name),
+            labelKey: 'ai-assistant.read.missing',
+            description: `the rows missing one thing: ${list.missing.map(one => `${one.name} - ${one.description}`).join('; ')}`,
+            filter: (v: any) => list.missing!.find(one => one.name === v)!.filters
+          }
+        ]
+      : []),
     ...(amount
       ? [
           { name: 'minAmount', type: 'number', labelKey: 'ai-assistant.read.min-amount', description: `at least this ${amount}${inCurrency}`, filter: (v: any) => ({ name: amount, operator: 'gte', value: v }) },

package/server/service/data-read/read-target.ts

@@ -9,7 +9,7 @@
  *
  * Pure but for the GraphQL runner, which comes in as an argument - the rules are tested without a server.
  */
-import { readFieldValue, rootFieldOf, type EntryField } from '../data-entry/entry-target.js'
+import { readFieldValue, recordIdOfKey, rootFieldOf, type EntryField } from '../data-entry/entry-target.js'
 import { encodeListQuery } from '@operato/utils/list-query.js'
 import type { GraphqlRunner } from '../data-entry/entry-update.js'
 import { parse } from 'graphql'
@@ -143,6 +143,8 @@ export interface DetailArg {
   values?: string[]
   description?: string
   required?: boolean
+  /** A record's id: the axis (or axes) of the record, whose key `<axis>:<id>` the model may have been shown (EntryField.axis). */
+  axis?: string | readonly string[]
 }
 
 /**
@@ -160,6 +162,11 @@ export interface DetailRead {
   /** One query with one root field. Its variables are the arguments - each declared in `args`. */
   query: string
   args?: DetailArg[]
+  /**
+   * The records the answer is about, whose screens put it in front (EntryTarget.axes) - the management check answers
+   * for any ledger record; asked on a deposit's 360 why it was in the check, the model never opened it (2026-10-24).
+   */
+  axes?: string[]
 }
 
 /** Characters of an answer handed to the model - a longer one is refused, and the model narrows it. */
@@ -200,8 +207,8 @@ export function detailReadOf(key: string | undefined): DetailRead | undefined {
 export function readCriteria(target: ReadTarget, args: any): { criteria: Record<string, unknown>; refused: { name: string; code: string }[] } {
   const criteria: Record<string, unknown> = {}
   const refused: { name: string; code: string }[] = []
-  /* One record by its id - every target takes it (the id a list answer or a find tool gave). */
-  if (typeof args?.id === 'string' && args.id.trim()) criteria.id = args.id.trim()
+  /* One record by its id - every target takes it (the id a list answer or a find tool gave, or the key `<axis>:<id>` an open record is shown by, the axis being the key's last part). */
+  if (typeof args?.id === 'string' && args.id.trim()) criteria.id = recordIdOfKey(target.key.split('.').pop()!, args.id) ?? args.id.trim()
   if (target.search && typeof args?.text === 'string' && args.text.trim()) criteria.text = args.text.trim()
   for (const criterion of target.criteria) {
     const value = args?.[criterion.name]

package/server/service/data-read/read-tools.ts

@@ -246,7 +246,7 @@ export async function queryDetail(target: DetailRead, args: any, run: GraphqlRun
       if (arg.required) refused.push({ name: arg.name, code: 'required' })
       continue
     }
-    const { read, code } = readFieldValue({ name: arg.name, type: arg.type === 'string' ? 'text' : arg.type, values: arg.values } as any, value)
+    const { read, code } = readFieldValue({ name: arg.name, type: arg.type === 'string' ? 'text' : arg.type, values: arg.values, axis: arg.axis } as any, value)
     if (read === undefined) refused.push({ name: arg.name, code: code ?? 'unreadable' })
     else variables[arg.name] = read
   }

package/server/service/data-read/record-keys.test.ts

@@ -0,0 +1,36 @@
+/*
+ * A read takes a record by the key it was shown by (2026-10-23) - `<axis>:<uuid>`, as an open record's anchor and an
+ * application's evidence write it. A 360 read and a list read asked by id took the key as the id and found nothing.
+ */
+import { readCriteria, type DetailRead, type ReadTarget } from './read-target'
+import { queryDetail } from './read-tools'
+
+const ID = 'f92c04ec-40c4-4be8-8160-080cff20e750'
+
+describe('a read names the record the model was shown', () => {
+  const lines = { key: 'office.cash-transaction', criteria: [] } as unknown as ReadTarget
+
+  it('★ a list read by id takes the key of its own axis - the target key\'s last part', () => {
+    expect(readCriteria(lines, { id: `cash-transaction:${ID}` }).criteria).toEqual({ id: ID })
+    expect(readCriteria(lines, { id: ID }).criteria).toEqual({ id: ID })
+    /* Another record's key is not this record - asked as written, it finds nothing. */
+    expect(readCriteria(lines, { id: `contract:${ID}` }).criteria).toEqual({ id: `contract:${ID}` })
+  })
+
+  it('★ a whole answer takes the key of the axis its id argument declares', async () => {
+    const summary: DetailRead = {
+      key: 'office.contract-360',
+      description: "one contract's 360.",
+      query: 'query ($id: String!) { contract360(id: $id) { code } }',
+      args: [{ name: 'id', type: 'string', required: true, axis: 'contract' }]
+    }
+    const asked: any[] = []
+    const run = async (_document: string, variables: any) => {
+      asked.push(variables)
+      return { data: { contract360: { code: 'H2026012' } } }
+    }
+    await queryDetail(summary, { id: `contract:${ID}` }, run)
+    await queryDetail(summary, { id: `cash-transaction:${ID}` }, run)
+    expect(asked).toEqual([{ id: ID }, { id: `cash-transaction:${ID}` }])
+  })
+})

package/server/service/index.ts

@@ -5,6 +5,7 @@ import { AssistantCapabilityResolver } from './assistant-capability-resolver.js'
 import { AiAgentResolver } from './ai-agent-resolver.js'
 import { MySessionActivitySubscription } from './chat-session/session-activity-subscription.js'
 import { ChatMessageSubscription } from './chat-message/chat-message-subscription.js'
+import { ChatTypingSubscription } from './chat-message/chat-typing-subscription.js'
 import { entities as ChatSessionEntities } from './chat-session/index.js'
 import { entities as ChatMessageEntities } from './chat-message/index.js'
 import { entities as ChatSessionParticipantEntities } from './chat-session-participant/index.js'
@@ -29,7 +30,9 @@ export * from './assistant-capability-resolver.js'
 export * from './tool-access.js'
 /* Data entry from material - an app registers what it can enter; a mode names it (design/ai/data-entry.md). */
 export * from './data-entry/entry-target.js'
-export { registerEntryTarget, entryCategoryOf } from './data-entry/entry-tools.js'
+export { registerEntryTarget, entryCategoryOf, runAsCaller } from './data-entry/entry-tools.js'
+/* An application's tool that prepares many changes at once makes the same change card the model's would (2026-10-24). */
+export { proposeChanges, MAX_CHANGES } from './data-entry/entry-update.js'
 /* Reading an application's lists - an app registers what it lets read; a mode names it (design/ai/read-targets.md). */
 export * from './data-read/read-target.js'
 export { registerReadTarget, readCategoryOf, registerDetailRead, detailCategoryOf } from './data-read/read-tools.js'
@@ -79,6 +82,8 @@ export const schema = {
     /* A domain's AI agents - the settings card and the dock's picker (design/ai/agent-settings.md). */
     AiAgentResolver,
     ChatMessageSubscription,
+    /* 「입력 중」 — 저장하지 않는 방의 한 줄. 듣는 사람은 메시지와 같은 방 판정을 지난다. */
+    ChatTypingSubscription,
     /* 내가 참여한 모든 세션의 활동 — 창을 닫아 둔 표면이 배지·목록을 갱신할 수 있게. */
     MySessionActivitySubscription,
     /* 사람이 누른 입력 제안을 쓰는 자리 — 행마다 앱의 코드로, 그 사람의 권한으로. */

package/server/service/testing/conversation-script.ts

@@ -126,7 +126,7 @@ export interface ConversationOptions {
    */
   participants?: ScriptParticipant[]
   /** 이 대화가 공개인가 — 기본은 공개(ADR-0073 판정 2). 'private' 이면 멘션이 사람을 앉히지 않는다. */
-  visibility?: 'open' | 'private'
+  visibility?: 'open' | 'group' | 'private'
   /** Who the assistant is on this surface — in real use it comes from the registered mode. */
   systemPrompt?: string
   /** Which registered categories this conversation may use. Omitted allows none. */

package/server/service/testing/mode-conformance.ts

@@ -145,6 +145,8 @@ export function modeCarriesSharedRules(kind: string): string[] {
   const found: string[] = []
   if (/name our plumbing|do not describe our machinery/i.test(prompt)) found.push('absence-rule-copy')
   if (/^\s*Next:/im.test(prompt) || /end the reply with one last line/i.test(prompt)) found.push('next-request-rule-copy')
+  if (/finish what was asked in this turn|never ask whether to propose/i.test(prompt)) found.push('finish-rule-copy')
+  if (/\[writer → addressee\]/.test(prompt)) found.push('speaker-rule-copy')
   return found
 }
 

package/test/assistant-dock.test.ts

@@ -168,7 +168,11 @@ describe('what twin needed of the dock', () => {
   })
 
   it('a carried conversation that could not be made is said, not swallowed', () => {
-    assert.match(dock, /this\.startCarried\(ask\)\.catch\(error => \{\s*notify\(\{ level: 'error'/)
+    assert.match(dock, /this\.startCarried\(ask\)\.catch\(\(?\w*\)? => \{\s*notify\(\{ level: 'error'/)
+  })
+
+  it('★ and nothing is sent into the previous conversation after it - the request depended on the context that failed', () => {
+    assert.match(dock, /this\.startCarried\(ask\)\.catch\([\s\S]*?return undefined\s*\}\)[\s\S]{0,200}?if \(!id\) return\n/)
   })
 })
 

package/test/assistant-session-manager.test.ts

@@ -58,11 +58,13 @@ describe('the doors are the framework ones, as they are', () => {
 })
 
 describe('nothing irreversible without asking', () => {
-  it('delete and making public ask first with the platform confirm; making private, hiding and renaming do not', () => {
+  it('delete, making public, making private (its people leave) and leaving ask first with the platform confirm; making it a group, hiding and renaming do not', () => {
     assert.match(manager, /import \{ OxPrompt \} from '@operato\/popup'/)
     assert.match(manager, /this\.askRemove\(entry, name\)/)
     assert.match(manager, /this\.askOpen\(entry, name\)/)
-    assert.match(manager, /@select=\$\{\(\) => this\.setVisibility\(entry, 'private'\)\}/)
+    assert.match(manager, /this\.askPrivate\(entry, name\)/)
+    assert.match(manager, /this\.askLeave\(entry, name\)/)
+    assert.match(manager, /@select=\$\{\(\) => this\.setVisibility\(entry, 'group'\)\}/)
   })
 
   it('no browser dialog - they sit outside the theme', () => {

package/test/open-doors.test.ts

@@ -55,12 +55,15 @@ const OPEN_BY_DECISION: Record<Root, Record<string, string>> = {
   Mutation: {},
   Subscription: {
     chatMessageActivity:
-      "subscribe: a member of the domain, and the room open to the caller — open to the domain, private to its participants " +
+      "subscribe: a member of the domain, and the room open to the caller — open to the domain, group or private to its seats " +
       '(ADR-0073 decision 2), refused with the words of a missing session otherwise. Every message: same domain + session, ' +
       'and the room asked again. The body is redacted by doors for each receiver (ADR-0073 ruling 1).',
     mySessionActivity:
       "subscribe: a member of the domain. Every message: same domain, and the caller among the payload's participants. " +
-      'Badge fields and a one-line preview only, no body.'
+      'Badge fields and a one-line preview only, no body.',
+    chatTyping:
+      'subscribe: a member of the domain, and the room open to the caller, asked as chatMessageActivity asks it. Every notice: ' +
+      "same domain + session, not the caller's own, and the room asked again. A user id, a name and a time - nothing stored, no body."
   }
 }
 
@@ -129,7 +132,7 @@ describe('what the walk itself has to be true for', () => {
     /* If the resolver list shrank to nothing, the lists above would pass by having nothing to look at. */
     expect(fieldsOf('Query').length).toBeGreaterThanOrEqual(10)
     expect(fieldsOf('Mutation').length).toBeGreaterThanOrEqual(13)
-    expect(fieldsOf('Subscription')).toHaveLength(2)
+    expect(fieldsOf('Subscription')).toHaveLength(3)
   })
 
   it('tells an undeclared field from one the schema does not have', () => {
@@ -145,11 +148,13 @@ describe('what the walk itself has to be true for', () => {
      * 2026-09-30: 30 — applyEntryProposal (enter the rows the person pressed, design/ai/data-entry.md), declared.
      * 2026-10-12: 35 — aiAgentSettings · aiAgentChoices · aiProviderModels · saveAiAgents · aiUsageSummary (a domain's AI
      *             agents and their usage, design/ai/agent-settings.md), declared.
+     * 2026-10-24: 41 — mayInviteToAISession · inviteToAISession · removeFromAISession · leaveAISession · sayTyping declared, chatTyping open (a
+     *             group conversation and its typing line, ADR-0073 decision 3).
      */
     const all = fieldsOf('Query').length + fieldsOf('Mutation').length + fieldsOf('Subscription').length
     const open = openFields('Query').length + openFields('Mutation').length + openFields('Subscription').length
 
-    expect(all).toBe(35)
-    expect(open).toBe(2)
+    expect(all).toBe(41)
+    expect(open).toBe(3)
   })
 })

package/translations/en.json

@@ -1,4 +1,5 @@
 {
+  "ai-assistant.dock.carry-failed": "The selected context could not be attached. Nothing was sent. Try again from the original screen.",
   "ai-assistant.dock.wait-before-switch": "Wait for the current response before changing conversations.",
   "ai-assistant.dock.switch-title": "Change conversation?",
   "ai-assistant.dock.switch-draft": "Your unsent text and attachments will not move to the other conversation.",
@@ -14,7 +15,7 @@
   "ai-assistant.session.reset-filters": "Clear search and filters",
   "ai-assistant.session.filtered-empty": "No conversations match these filters here.",
   "ai-assistant.session.scope-empty": "No conversations yet.",
-  "ai-assistant.session.audience-private": "Participants only",
+  "ai-assistant.session.audience-private": "Only me",
   "ai-assistant.session.audience-open": "Everyone in this domain",
   "ai-assistant.session.manage": "Manage conversation",
   "ai-assistant.session.list": "Conversations",
@@ -121,7 +122,6 @@
   "ai-assistant.text.say-to-room-tooltip": "say this to the people here — the assistant does not answer",
   "ai-assistant.text.no-room-yet": "this conversation is not saved yet, so there is nobody else in it to talk to",
   "ai-assistant.text.will-be-invited": "{names} will join this conversation when you send",
-  "ai-assistant.text.cannot-invite": "{names} will not join — only the people already in this conversation can bring someone in",
   "ai-assistant.text.answer-needs-permission": "you do not have permission to see this answer. ask an administrator for access.",
   "ai-assistant.label.conversation": "conversation",
   "ai-assistant.text.switch-conversation": "switch to {name}",
@@ -182,7 +182,7 @@
   "ai-assistant.session.filter-whose": "Whose",
   "ai-assistant.session.filter-participant": "I'm in",
   "ai-assistant.session.filter-visibility": "Visibility",
-  "ai-assistant.session.filter-any-visibility": "Public and private",
+  "ai-assistant.session.filter-any-visibility": "Any audience",
   "ai-assistant.session.filter-open": "Public",
   "ai-assistant.session.filter-private": "Private",
   "ai-assistant.session.filter-unread": "Unread",
@@ -247,6 +247,7 @@
   "ai-assistant.read.year": "year",
   "ai-assistant.read.month": "month",
   "ai-assistant.read.flow": "in or out",
+  "ai-assistant.read.missing": "missing",
   "ai-assistant.read.period": "month",
   "ai-assistant.read.status": "status",
   "ai-assistant.read.min-amount": "minimum amount",
@@ -399,5 +400,29 @@
   "ai-assistant.run.assistant-run-model-error": "the AI model failed during the run.",
   "ai-assistant.run.assistant-run-abandoned": "the run stopped partway and was started again.",
   "ai-assistant.run.ai-not-configured": "AI is not set up for this domain.",
-  "ai-assistant.run.ai-agent-not-available": "the AI agent picked for this run is not available here."
+  "ai-assistant.run.ai-agent-not-available": "the AI agent picked for this run is not available here.",
+  "ai-assistant.text.cannot-invite-private": "{names} will not join — a private conversation is yours alone. Make it a group to bring people in",
+  "ai-assistant.text.cannot-invite-group": "{names} will not join — only the person who started this group can bring someone in",
+  "ai-assistant.button.invite": "Invite",
+  "ai-assistant.label.participants": "People in this conversation",
+  "ai-assistant.button.remove-participant": "Send {name} out",
+  "ai-assistant.text.invited": "{name} can now read and write here, and has been told.",
+  "ai-assistant.text.removed-participant": "{name} is no longer in this conversation.",
+  "ai-assistant.text.typing-many": "{count} people are typing",
+  "ai-assistant.text.typing": "Typing: {names}",
+  "ai-assistant.text.invite-search": "Name or email",
+  "ai-assistant.text.invite-none-found": "No one to invite by that name.",
+  "ai-assistant.session.filter-group": "Group",
+  "ai-assistant.session.make-group": "Make it a group",
+  "ai-assistant.session.leave": "Leave",
+  "ai-assistant.session.confirm-private": "Make \"{name}\" private? Only you will read it, and everyone else in it leaves.",
+  "ai-assistant.session.confirm-leave-open": "Leave \"{name}\"? Its new messages stop reaching you.",
+  "ai-assistant.session.confirm-leave": "Leave \"{name}\"? You will not read it again unless its owner brings you back.",
+  "ai-assistant.session.leave-refused": "you could not leave this conversation.",
+  "ai-assistant.session.audience-group": "Invited people",
+  "ai-assistant.text.invite-title": "Conversation invite",
+  "ai-assistant.text.invite-body-named": "{who} brought you into the conversation \"{name}\".",
+  "ai-assistant.text.invite-body": "{who} brought you into a conversation.",
+  "ai-assistant.text.board-invite-title": "Board collaboration invite",
+  "ai-assistant.text.board-invite-body": "{who} invited you to collaborate on a board."
 }