@things-factory/ai-assistant 10.1.205 → 10.1.207

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/ai-assistant",
-  "version": "10.1.205",
+  "version": "10.1.207",
   "main": "dist-server/index.js",
   "things-factory": true,
   "author": "heartyoh",
@@ -35,13 +35,13 @@
     "@operato/shell": "^10.29.39",
     "@operato/styles": "^10.0.0",
     "@operato/utils": "^10.29.39",
-    "@things-factory/ai-client-base": "^10.1.205",
-    "@things-factory/apptool-base": "^10.1.205",
-    "@things-factory/attachment-base": "^10.1.205",
-    "@things-factory/auth-base": "^10.1.205",
+    "@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/env": "^10.1.149",
-    "@things-factory/setting-base": "^10.1.205",
-    "@things-factory/shell": "^10.1.205",
+    "@things-factory/setting-base": "^10.1.206",
+    "@things-factory/shell": "^10.1.206",
     "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": "7311492aa5eaa00993c0325053f5f7ae8b1fb024"
+  "gitHead": "e6e3fbf5c353629adbeb8850093150b14254e059"
 }

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

@@ -16,10 +16,13 @@ import { openSubjectLine, registryAssistantChat } from '@things-factory/ai-clien
 
 import { getAssistantMode, getAssistantModeWarnings } from '../assistant-mode/registry.js'
 import { assistantModeView, resolveModeSettings, type Translate } from '../assistant-mode/resolve.js'
+import { modeFrontCategories, type TurnScreen } from '../assistant-mode/mode-categories.js'
 
 export interface ModeRunResult {
   /** 이 모드가 모델에게 실제로 건넨 도구 이름. */
   offeredTools: string[]
+  /** 건네지 않았지만 모델이 openTools 로 꺼낼 수 있던 도구 — 둘을 합치면 이 모드로 쓸 수 있는 전부(ADR-0061 결정 9). */
+  openableTools: string[]
   /** 모델이 받은 시스템 프롬프트 — 서버의 것인지 확인할 수 있다. */
   systemPrompt: string
   /** 첫 턴에 도구를 강제했는가. */
@@ -37,7 +40,7 @@ export const keyEchoTranslate: Translate = key => key
  */
 export async function runRegisteredMode(
   kind: string,
-  options: { client: any; hostContext?: any; state?: any; toolAccess?: any; reply?: string } = {} as any
+  options: { client: any; hostContext?: any; state?: any; toolAccess?: any; reply?: string; screen?: TurnScreen } = {} as any
 ): Promise<ModeRunResult> {
   const settings = resolveModeSettings({ kind }, keyEchoTranslate)
   let requiredToolOnFirstTurn = false
@@ -47,6 +50,8 @@ export async function runRegisteredMode(
     messages: [{ role: 'user', content: '한 턴' }] as any,
     systemPrompt: settings.systemPrompt,
     toolCategories: settings.toolCategories,
+    /* What the door puts in front on that screen (ADR-0061 decision 9) - a mode too large for one call is offered as a person meets it. */
+    front: { categories: modeFrontCategories(getAssistantMode(kind) ?? {}, options.screen ?? {}) },
     requireToolOnFirstTurn: (requiredToolOnFirstTurn = Boolean(settings.requireToolOnFirstTurn)),
     temperature: settings.temperature,
     maxTokens: settings.maxTokens,
@@ -65,6 +70,7 @@ export async function runRegisteredMode(
 
   return {
     offeredTools: [...result.offeredTools],
+    openableTools: [...result.openableTools],
     systemPrompt: settings.systemPrompt,
     requiredToolOnFirstTurn,
     reply: result.reply

package/server/service/unattended-run/run-unattended.ts

@@ -187,6 +187,8 @@ export async function runAssistantUnattended(input: UnattendedRunInput, deps: Un
         messages,
         systemPrompt,
         toolCategories: categories,
+        /* No screen and no conversation - the mode's own tools in front, the lists opened as the run needs (ADR-0061 decision 9). */
+        front: { categories: mode.toolCategories ?? [] },
         mode: { kind: mode.kind, ...(input.mode.target ? { target: input.mode.target } : {}) },
         toolAccess: deps.toolAccess(state),
         hostContext: input.hostContext,

package/test/assistant-dock.test.ts

@@ -144,7 +144,7 @@ describe('attachments in the chat follow the mode', () => {
     /* Without it the client sends the File as {} and the server refuses the upload (found on :3700, 2026-09-25). */
     assert.match(chat, /context: \{ hasUpload: true \}/)
     /* Sent with the turn's input - the agent the person picked follows it (design/ai/agent-settings.md §5). */
-    assert.match(chat, /\n\s*attachmentIds,\s*\n\s*agentId: this\.agentId\s*\n\s*\}\)/)
+    assert.match(chat, /\n\s*attachmentIds,\s*\n\s*agentId: this\.agentId,\s*\n\s*page: \(store\.getState\(\) as any\)\?\.route\?\.page \|\| undefined\s*\n\s*\}\)/)
   })
 
   it('a stored file opens through the conversation route', () => {