@things-factory/ai-assistant 10.1.207 → 10.1.208

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/ai-assistant",
-  "version": "10.1.207",
+  "version": "10.1.208",
   "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": "ffc1ceaa9471b9f4a9b86f46c3021f2fed72d17d"
 }

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

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

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, 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/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, 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,48 @@ 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/)
   })
 })

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

@@ -13,18 +13,47 @@ 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.'
+
 /** 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.'
+  '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, 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 +72,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/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/data-entry/data-entry-update.test.ts

@@ -74,6 +74,17 @@ describe('which record is meant', () => {
     expect(resolveChangeRefs('office.expense-line', [{ ref: 'current', values: {} }], { record: { target: 'office.contract', id: 'c1' } }).unresolved).toEqual(['current'])
   })
 
+  /* 2026-10-23: the open record is named to the model by its key; a change naming it so found nothing. */
+  it('★ the key a record was shown by names it - `<axis>:<id>`, the axis being the target key\'s last part', () => {
+    const id = 'f92c04ec-40c4-4be8-8160-080cff20e750'
+    const picked = (key: string, ref: string) => resolveChangeRefs(key, [{ ref, values: {} }], undefined).picked.map(one => one.id)
+    expect(picked('office.contract-round', `contract-round:${id}`)).toEqual([id])
+    expect(picked('office.contract-round', id)).toEqual([id])
+    /* Another record's key is not this record, whatever its uuid - it is looked up as written and found by nobody. */
+    expect(picked('office.contract-round', `contract:${id}`)).toEqual([`contract:${id}`])
+    expect(picked('office.contract', `contract-round:${id}`)).toEqual([`contract-round:${id}`])
+  })
+
   it('★ an id from the screen is only a candidate - a record the person cannot read is not found, and nothing is shown of it', async () => {
     const result: any = await proposeChanges(expense, { changes: [{ ref: 'current', values: { amount: 13000 } }] }, { host: { record: { id: 'someone-elses' } } }, run)
     expect(result.rows[0].issues).toEqual([{ code: 'record-not-found', blocking: true }])

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
@@ -381,11 +405,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 +675,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), an id a find tool returned, or the record\'s key (`<kind>:<id>`) as you were shown it. ' +
         '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 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')
     }

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[]
 }
 
 /**
@@ -200,8 +202,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/testing/mode-conformance.ts

@@ -145,6 +145,7 @@ 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')
   return found
 }
 

package/translations/ko.json

@@ -260,7 +260,7 @@
   "ai-assistant.entry.change": "{count}건 수정",
   "ai-assistant.entry.title-create": "{name} 입력안",
   "ai-assistant.entry.title-update": "{name} 수정안",
-  "ai-assistant.entry.changed": "{count}건을 고쳤습니다.",
+  "ai-assistant.entry.changed": "{count}건을 수정했습니다.",
   "ai-assistant.entry.changed-none": "수정된 기록이 없습니다.",
   "ai-assistant.entry.changes": "{count}건",
   "ai-assistant.entry.not-changed": "{count}건은 변경하지 않습니다.",
@@ -399,5 +399,5 @@
   "ai-assistant.run.assistant-run-model-error": "실행 중 AI 모델 호출이 실패했습니다.",
   "ai-assistant.run.assistant-run-abandoned": "실행이 도중에 멈춰 다시 시작했습니다.",
   "ai-assistant.run.ai-not-configured": "이 사업장에는 AI 가 설정되어 있지 않습니다.",
-  "ai-assistant.run.ai-agent-not-available": "이 실행에 고른 AI 에이전트를 여기서 쓸 수 없습니다."
+  "ai-assistant.run.ai-agent-not-available": "이 실행에서 선택한 AI 에이전트는 현재 사용할 수 없습니다."
 }