@things-factory/ai-assistant 10.1.206 → 10.1.208

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/ai-assistant",
-  "version": "10.1.206",
+  "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.206",
-    "@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": "18588a058a4a6cb21c379b2da5517e077c6442ba"
+  "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-chat-resolver.ts

@@ -27,7 +27,7 @@ import { GraphQLJSON } from 'graphql-scalars'
 import '@things-factory/auth-base'
 
 import { getRepository, rethrowSpoken } from '@things-factory/shell'
-import { aiClientFor, findToolSpec, openSubjectLine, registryAssistantChat, type AgentClient } from '@things-factory/ai-client-base'
+import { aiClientFor, findToolSpec, openSubjectLine, OPEN_TOOLS, registryAssistantChat, type AgentClient } from '@things-factory/ai-client-base'
 
 import { ChatSession } from './chat-session/chat-session.js'
 import { assertStationSession } from './chat-session/station-session-guard.js'
@@ -54,6 +54,8 @@ import { attachmentForModel, describeAttachment, findChatAttachment } from './ch
 import { readTurnAttachments } from './chat-session/turn-attachments.js'
 import { getAssistantMode } from './assistant-mode/registry.js'
 import { resolveModeSettings } from './assistant-mode/resolve.js'
+import { modeFrontCategories } from './assistant-mode/mode-categories.js'
+import { usedToolNames } from './chat-message/used-tools.js'
 import { splitNextRequest } from './assistant-mode/screen-rules.js'
 import { requestTranslator } from './request-translator.js'
 
@@ -134,6 +136,13 @@ class AssistantChatInput {
       'The AI agent the person picked for this turn, from aiAgentChoices. Omitted takes the domain default. An agent this domain cannot use is refused - the provider, the model and the key are always the server\'s.'
   })
   agentId?: string
+
+  @Field({
+    nullable: true,
+    description:
+      'The route of the page the dock is on (cash-transaction-list). It decides which tools the model is offered first; what a person may use is decided as without it.'
+  })
+  page?: string
 }
 
 @ObjectType()
@@ -506,6 +515,17 @@ export class AssistantChatResolver {
       messages: conversation as any,
       systemPrompt,
       toolCategories: settings.toolCategories,
+      /*
+       * What goes in front when the mode's tools do not fit in one call (ADR-0061 decision 9): the open page's and the
+       * anchored record's, then what this conversation used. The anchor is the stored one, never the client's.
+       */
+      front: {
+        categories: modeFrontCategories(getAssistantMode(input.mode.kind) ?? {}, {
+          page: input.page,
+          subjectAxis: (session as any)?.anchorType === 'subject' ? String((session as any).anchorId ?? '').split(':')[0] || undefined : undefined
+        }),
+        tools: usedToolNames(storedRows as any, [OPEN_TOOLS])
+      },
       /* 도구가 「어느 대화에서 불렸나」를 안다 — 서버의 값이다(ADR-0061 결정 3). */
       mode: { kind: input.mode.kind, ...(input.mode.target ? { target: input.mode.target } : {}) },
       toolAccess: toolAccessFor(context),

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/mode-categories.ts

@@ -1,4 +1,5 @@
-/* Pure - read by the resolver and by the boot report, so the report and the conversation open the same tools. */
+/* 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'
 /**
  * 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).
@@ -23,3 +24,48 @@ export function modeToolCategories(mode: { toolCategories?: string[]; attachment
 export function unattendedToolCategories(mode: { toolCategories?: string[]; readTargets?: string[] }): string[] {
   return [...new Set([...(mode.toolCategories ?? []), ...(mode.readTargets ?? []).map(key => `data-read:${key}`)])]
 }
+
+/** The screen a turn is asked from - the page the dock is on, and the record its conversation is anchored to. */
+export interface TurnScreen {
+  /** The application's route of the open page (`cash-transaction-list`), as the dock sends it. */
+  page?: string
+  /** The axis of the record the conversation is anchored to (`contract` of `subject` · `contract:<id>`), from the stored anchor. */
+  subjectAxis?: string
+}
+
+type FrontMode = { toolCategories?: string[]; attachments?: { kinds?: string[] }; entryTargets?: string[]; readTargets?: string[] }
+
+/**
+ * The records the open screen is about, among those the mode reads and enters (ADR-0061 decision 9). Nothing new is
+ * declared: a read target's screen route is the page that lists it, and a key's last part is the axis of its record
+ * (`office.contract` is the record of the axis `contract`) - reading and entering one record share its key.
+ */
+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))
+}
+
+/**
+ * The categories a turn puts in front when the mode's tools do not fit in one call: the mode's own, the AI 작업판, the
+ * attachment reader, and the open screen's records. The rest the model opens with `openTools`.
+ */
+export function modeFrontCategories(mode: FrontMode, screen: TurnScreen = {}): string[] {
+  const keys = screenTargetKeys(mode, screen)
+  return [
+    ...new Set([
+      ...(mode.toolCategories ?? []),
+      'assistant-workspace',
+      ...(mode.attachments?.kinds?.length ? ['chat-attachments'] : []),
+      ...keys.filter(key => (mode.readTargets ?? []).includes(key)).map(key => `data-read:${key}`),
+      ...keys.filter(key => (mode.entryTargets ?? []).includes(key)).map(key => `data-entry:${key}`)
+    ])
+  ]
+}
+
+/** Each screen the mode could be asked from - a page that lists one of its records, a record's axis - for the boot report. */
+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()!))]
+  return [{}, ...pages.map(page => ({ page })), ...axes.map(subjectAxis => ({ subjectAxis }))]
+}

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

@@ -0,0 +1,65 @@
+/*
+ * 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 { listReadTarget } from '../data-read/list-read'
+import { modeFrontCategories, modeScreens, screenTargetKeys } from './mode-categories'
+
+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)
+
+const mode = {
+  toolCategories: ['office-ops'],
+  attachments: { kinds: ['image'] },
+  readTargets: ['office.cash-transaction', 'office.contract', 'office.contract-allocation', 'office.loan-summary'],
+  entryTargets: ['office.cash-transaction', 'office.contract', 'office.contract-round', 'office.expense-line']
+}
+
+beforeEach(() => {
+  clearReadTargets()
+  declareReadTarget(list('office.cash-transaction', 'cash-transaction-list'))
+  declareReadTarget(list('office.contract', 'contract-list'))
+  declareReadTarget(list('office.contract-allocation', 'contract-allocation-list'))
+})
+
+describe('the open screen decides what goes in front', () => {
+  it('★ a list page: that list read and its record entered - one key, both ways', () => {
+    expect(modeFrontCategories(mode, { page: 'cash-transaction-list' })).toEqual([
+      'office-ops',
+      'assistant-workspace',
+      'chat-attachments',
+      'data-read:office.cash-transaction',
+      'data-entry:office.cash-transaction'
+    ])
+  })
+
+  it('★ a record\'s conversation: the keys whose last part is its axis - never a key that only starts with it', () => {
+    expect(screenTargetKeys(mode, { subjectAxis: 'contract' })).toEqual(['office.contract'])
+    expect(screenTargetKeys(mode, { subjectAxis: 'contract-round' })).toEqual(['office.contract-round'])
+  })
+
+  it('★ a record the mode does not read or enter is not put in front', () => {
+    expect(modeFrontCategories({ ...mode, readTargets: [], entryTargets: [] }, { page: 'cash-transaction-list' })).toEqual(['office-ops', 'assistant-workspace', 'chat-attachments'])
+  })
+
+  it('no screen: the mode\'s own, the AI 작업판 and the attachment reader', () => {
+    expect(modeFrontCategories(mode)).toEqual(['office-ops', 'assistant-workspace', 'chat-attachments'])
+    expect(modeFrontCategories(mode, { page: 'some-other-page' })).toEqual(['office-ops', 'assistant-workspace', 'chat-attachments'])
+  })
+
+  it('the screens the boot report walks: none, each list page, each axis', () => {
+    expect(modeScreens(mode)).toEqual([
+      {},
+      { page: 'cash-transaction-list' },
+      { page: 'contract-list' },
+      { page: 'contract-allocation-list' },
+      { subjectAxis: 'cash-transaction' },
+      { subjectAxis: 'contract' },
+      { subjectAxis: 'contract-allocation' },
+      { subjectAxis: 'loan-summary' },
+      { subjectAxis: 'contract-round' },
+      { subjectAxis: 'expense-line' }
+    ])
+  })
+})

package/server/service/assistant-mode/open-subject-door.test.ts

@@ -27,3 +27,19 @@ describe('the door', () => {
     expect(door).not.toMatch(/content: result\.reply/)
   })
 })
+
+describe('what the door puts in front (ADR-0061 decision 9)', () => {
+  const block = door.slice(door.indexOf('      front: {'), door.indexOf('      /* 도구가 「어느 대화에서 불렸나」를 안다'))
+
+  it('★ the open page, the stored anchor\'s axis and the tools this conversation used - never the anchor the screen sent', () => {
+    expect(block).toMatch(/modeFrontCategories\(getAssistantMode\(input\.mode\.kind\) \?\? \{\}, \{/)
+    expect(block).toMatch(/page: input\.page,/)
+    expect(block).toMatch(/\(session as any\)\?\.anchorType === 'subject' \? String\(\(session as any\)\.anchorId/)
+    expect(block).toMatch(/tools: usedToolNames\(storedRows as any, \[OPEN_TOOLS\]\)/)
+    expect(block).not.toMatch(/hostContext/)
+  })
+
+  it('★ the page is a field of its own on the input, never read out of the host context', () => {
+    expect(door).toMatch(/\n  page\?: string\n\}\n\n@ObjectType\(\)/)
+  })
+})

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

@@ -113,3 +113,59 @@ it('★ a slash sentence may need a read target\'s tool - the check opens what t
   registerAssistantMode(spec({ readTargets: ['office.contract'], slashTemplates: [{ name: 'contracts', descriptionKey: 'k', templateKey: 't', tools: ['queryOfficeContract'] }] }))
   expect(getAssistantModeWarnings()).toEqual([])
 })
+
+describe('what a turn puts in front fits in one call (ADR-0061 decision 9)', () => {
+  const many = (prefix: string, count: number) =>
+    Array.from({ length: count }, (_, i) => {
+      registerToolCategory({
+        name: `${prefix}-${i}`,
+        guidance: 'call it before answering',
+        specs: [{ kind: 'read', name: `${prefix}Tool${i}`, description: 'one tool', schema: {}, builder: () => ({}) } as any]
+      } as any)
+      return `${prefix}-${i}`
+    })
+
+  it('★ a mode whose own tools do not leave room for openTools is reported by code at boot', () => {
+    registerAssistantMode(spec({ kind: 'office.finance', toolCategories: many('own', 70) }))
+
+    expect(getAssistantModeWarnings()).toContainEqual(
+      expect.objectContaining({ code: 'assistant-mode-front-over-budget', params: expect.objectContaining({ kind: 'office.finance', front: 70, budget: 64 }) })
+    )
+  })
+
+  it('★ a large mode whose front fits is not reported - the rest is opened as needed', () => {
+    const lists = Array.from({ length: 100 }, (_, i) => `office.list-${i}`)
+    for (const key of lists) {
+      registerToolCategory({
+        name: `data-read:${key}`,
+        guidance: 'call it before answering',
+        specs: [{ kind: 'read', name: `query${key.replace(/\W/g, '')}`, description: 'one list', schema: {}, builder: () => ({}) } as any]
+      } as any)
+    }
+    registerAssistantMode(spec({ kind: 'office.finance', toolCategories: many('own', 10), readTargets: lists }))
+
+    expect(getAssistantModeWarnings().filter(warning => warning.code === 'assistant-mode-front-over-budget')).toEqual([])
+  })
+
+  it('★ the front counts the screen\'s record and openTools - 62 of its own fit, 63 do not', () => {
+    const lists = Array.from({ length: 10 }, (_, i) => `office.list-${i}`)
+    for (const key of lists) {
+      registerToolCategory({
+        name: `data-read:${key}`,
+        guidance: 'call it before answering',
+        specs: [{ kind: 'read', name: `query${key.replace(/\W/g, '')}`, description: 'one list', schema: {}, builder: () => ({}) } as any]
+      } as any)
+    }
+    registerAssistantMode(spec({ kind: 'office.fits', toolCategories: many('fits', 62), readTargets: lists }))
+    registerAssistantMode(spec({ kind: 'office.full', toolCategories: many('full', 63), readTargets: lists }))
+
+    const over = getAssistantModeWarnings().filter(warning => warning.code === 'assistant-mode-front-over-budget')
+    expect(over.map(warning => [warning.params.kind, warning.params.front])).toEqual([['office.full', 64]])
+  })
+
+  it('a mode that fits whole is offered whole and never reported', () => {
+    registerAssistantMode(spec({ toolCategories: many('small', 60) }))
+
+    expect(getAssistantModeWarnings().filter(warning => warning.code === 'assistant-mode-front-over-budget')).toEqual([])
+  })
+})

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

@@ -12,8 +12,8 @@
  * after every module is in.
  */
 import { entryTargetOf } from '../data-entry/entry-target.js'
-import { getToolSpecsFor } from '@things-factory/ai-client-base'
-import { modeToolCategories } from './mode-categories'
+import { getToolSpecsFor, MAX_OFFERED_TOOLS } from '@things-factory/ai-client-base'
+import { modeFrontCategories, modeScreens, modeToolCategories } from './mode-categories'
 
 import type { AssistantModeSpec, AssistantModeWarning } from './types'
 
@@ -107,6 +107,24 @@ export function getAssistantModeWarnings(): ReadonlyArray<AssistantModeWarning>
       }
     }
   }
+  for (const mode of modes.values()) {
+    /*
+     * What a turn puts in front, on the screen that puts the most (ADR-0061 decision 9). The front is offered whole or
+     * the turn is refused, so a mode whose front does not fit with openTools fails every turn of that screen.
+     */
+    const answering = (categories: string[]) => getToolSpecsFor(categories).filter(spec => spec.kind === 'read').length
+    if (answering(modeToolCategories(mode) ?? []) <= MAX_OFFERED_TOOLS) continue
+    for (const screen of modeScreens(mode)) {
+      const front = answering(modeFrontCategories(mode, screen))
+      if (front + 1 <= MAX_OFFERED_TOOLS) continue
+      out.push({
+        code: 'assistant-mode-front-over-budget',
+        params: { kind: mode.kind, front, budget: MAX_OFFERED_TOOLS, ...screen },
+        message: `mode '${mode.kind}' puts ${front} tools in front${screen.page ? ` on '${screen.page}'` : ''}${screen.subjectAxis ? ` for a '${screen.subjectAxis}'` : ''} - with openTools more than one call carries (${MAX_OFFERED_TOOLS}). Narrow its own tool categories.`
+      })
+      break
+    }
+  }
   return out
 }
 

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/assistant-mode/types.ts

@@ -118,9 +118,21 @@ export interface AssistantModeWarning {
    * `assistant-mode-slash-outside-tools` — a `/` sentence needs a tool this mode does not open.
    * `assistant-mode-subject-claimed-twice` — two conversations name the same subject type.
    * `assistant-mode-entry-target-unknown` — a record the mode enters that no application registered.
+   * `assistant-mode-front-over-budget` — what a turn puts in front on some screen does not fit in one call (ADR-0061 decision 9).
    */
-  code: 'assistant-mode-slash-outside-tools' | 'assistant-mode-subject-claimed-twice' | 'assistant-mode-entry-target-unknown'
-  params: { kind: string; slash?: string; tool?: string; subject?: string; kinds?: string[]; target?: string }
+  code: 'assistant-mode-slash-outside-tools' | 'assistant-mode-subject-claimed-twice' | 'assistant-mode-entry-target-unknown' | 'assistant-mode-front-over-budget'
+  params: {
+    kind: string
+    slash?: string
+    tool?: string
+    subject?: string
+    kinds?: string[]
+    target?: string
+    front?: number
+    budget?: number
+    page?: string
+    subjectAxis?: string
+  }
   /** For a person reading the boot log; callers act on the code and params. */
   message: string
 }

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

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

package/server/service/chat-message/used-tools.test.ts

@@ -0,0 +1,19 @@
+import { usedToolNames } from './used-tools'
+
+const answer = (...names: string[]) => ({ role: 'assistant', toolUsages: JSON.stringify(names.map(name => ({ name, arguments: {}, kind: 'read' }))) })
+
+describe('the tools a conversation used, for the front of the next turn (ADR-0061 decision 9)', () => {
+  it('★ the latest answer first, the latest call of it first, each once', () => {
+    const rows = [answer('readA', 'readB'), { role: 'user', toolUsages: undefined }, answer('readC', 'readA')]
+    expect(usedToolNames(rows)).toEqual(['readA', 'readC', 'readB'])
+  })
+
+  it('★ the opening tool is not a tool to put in front', () => {
+    expect(usedToolNames([answer('openTools', 'readA')], ['openTools'])).toEqual(['readA'])
+  })
+
+  it('a person\'s line and a trace that does not read are skipped', () => {
+    const rows = [{ role: 'user', toolUsages: JSON.stringify([{ name: 'readX' }]) }, { role: 'assistant', toolUsages: '{broken' }, answer('readA')]
+    expect(usedToolNames(rows)).toEqual(['readA'])
+  })
+})

package/server/service/chat-message/used-tools.ts

@@ -0,0 +1,25 @@
+/**
+ * The tools the earlier answers of a conversation called, the latest first (ADR-0061 decision 9).
+ *
+ * A turn puts them in front after the open screen's records, so a question that follows on from the last one finds the
+ * tool it needs without opening it again. Read from the stored trace (`ChatMessage.toolUsages`); a trace that does not
+ * read is skipped, as the dock's tool panel skips it.
+ */
+export function usedToolNames(rows: ReadonlyArray<{ role?: string; toolUsages?: string | null }>, skip: ReadonlyArray<string> = []): string[] {
+  const out: string[] = []
+  for (const row of [...rows].reverse()) {
+    if (row.role !== 'assistant' || !row.toolUsages) continue
+    let usages: unknown
+    try {
+      usages = JSON.parse(row.toolUsages)
+    } catch {
+      continue
+    }
+    if (!Array.isArray(usages)) continue
+    for (const usage of [...usages].reverse()) {
+      const name = typeof usage?.name === 'string' ? usage.name : undefined
+      if (name && !skip.includes(name) && !out.includes(name)) out.push(name)
+    }
+  }
+  return out
+}

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