@things-factory/ai-assistant 10.1.157 → 10.1.160

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/ai-assistant",
-  "version": "10.1.157",
+  "version": "10.1.160",
   "main": "dist-server/index.js",
   "things-factory": true,
   "author": "heartyoh",
@@ -34,12 +34,12 @@
     "@operato/popup": "^10.16.0",
     "@operato/shell": "^10.0.0",
     "@operato/styles": "^10.0.0",
-    "@things-factory/ai-client-base": "^10.1.157",
+    "@things-factory/ai-client-base": "^10.1.159",
     "@things-factory/apptool-base": "^10.1.157",
-    "@things-factory/attachment-base": "^10.1.157",
-    "@things-factory/auth-base": "^10.1.157",
+    "@things-factory/attachment-base": "^10.1.159",
+    "@things-factory/auth-base": "^10.1.159",
     "@things-factory/env": "^10.1.149",
-    "@things-factory/setting-base": "^10.1.157",
+    "@things-factory/setting-base": "^10.1.159",
     "@things-factory/shell": "^10.1.157",
     "dompurify": "^3.0.0",
     "exceljs": "4.2.0",
@@ -54,5 +54,5 @@
     "copyfiles": "^2.4.1",
     "rimraf": "^5.0.0"
   },
-  "gitHead": "bde810f804966549a7041457ad7ede40fcb78488"
+  "gitHead": "b5e86be374e8b913a3f2b8459b6001e8f44e345b"
 }

package/server/index.ts

@@ -27,3 +27,5 @@
  */
 export * from './service/index.js'
 import './tool-registry-boot-report.js'
+/* The site, an application's home and a board are named without an application's help (design/ai/screen-pattern.md §2-1). */
+import './service/assistant-mode/fallback-subjects.js'

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, registryAssistantChat, type AgentClient } from '@things-factory/ai-client-base'
+import { aiClientFor, findToolSpec, openSubjectLine, 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'
@@ -52,6 +52,7 @@ import { attachmentHistoryLine, refuseAttachments, textCharsOf } from './chat-se
 import { attachmentForModel, describeAttachment, findChatAttachment } from './chat-session/session-attachments.js'
 import { getAssistantMode } from './assistant-mode/registry.js'
 import { resolveModeSettings } from './assistant-mode/resolve.js'
+import { splitNextRequest } from './assistant-mode/screen-rules.js'
 import { requestTranslator } from './request-translator.js'
 
 /**
@@ -138,6 +139,13 @@ class AssistantChatOutput {
   @Field({ description: 'The reply, including the notice when the loop stopped early.' })
   reply: string
 
+  @Field(() => String, {
+    nullable: true,
+    description:
+      'The request the person is likely to make next, as the reply named it. The input shows it and Tab writes it in. Not stored with the reply.'
+  })
+  suggestion?: string | null
+
   @Field({ description: 'AI client identifier (provider:model).' })
   clientId: string
 
@@ -290,6 +298,20 @@ export class AssistantChatResolver {
 
     assertStationSession(session, input.hostContext, t)
 
+    /*
+     * 열린 대상 — 서버가 저장한 앵커에서 턴마다 한 줄(design/ai/screen-pattern.md §2-1). 화면이 보낸 hostContext 는
+     * 쓰지 않는다. 대상이 바뀌면 다음 턴의 줄도 바뀌므로 옛 대상이 대화에 남지 않는다.
+     */
+    const subjectLine = session
+      ? await openSubjectLine({
+          anchorType: (session as any).anchorType,
+          anchorId: (session as any).anchorId,
+          domain,
+          state: context.state
+        })
+      : undefined
+    const systemPrompt = subjectLine ? `${settings.systemPrompt}\n\n${subjectLine}` : settings.systemPrompt
+
     const lastUserMessage = input.messages[input.messages.length - 1]
     let userMessageId: string | undefined
 
@@ -480,7 +502,7 @@ export class AssistantChatResolver {
     const result = await registryAssistantChat({
       client,
       messages: conversation as any,
-      systemPrompt: settings.systemPrompt,
+      systemPrompt,
       toolCategories: settings.toolCategories,
       /* 도구가 「어느 대화에서 불렸나」를 안다 — 서버의 값이다(ADR-0061 결정 3). */
       mode: { kind: input.mode.kind, ...(input.mode.target ? { target: input.mode.target } : {}) },
@@ -495,7 +517,7 @@ export class AssistantChatResolver {
        * 자체를 안 보게 된다.
        */
       groundingSources: groundingSourcesFor({
-        systemPrompt: settings.systemPrompt,
+        systemPrompt,
         messages: conversation as any,
         hostContext: input.hostContext
       }),
@@ -509,6 +531,9 @@ export class AssistantChatResolver {
      * 이 답이 지나온 문 — ADR-0073 판정 1. 행에도, 목록 미리보기에도 같은 값이 간다. 한쪽만 적으면
      * 가려진 답이 목록에는 그대로 뜬다.
      */
+    /* The reply ends with the next request when one is natural; the input offers it and the stored answer does not keep it (§4-1). */
+    const { reply, suggestion } = splitNextRequest(result.reply)
+
     const answerDoors = doorsForAnswer(
       (result.loop.toolUsages ?? []).map((usage: any) => usage?.name).filter(Boolean),
       name => (findToolSpec(name, settings.toolCategories) as any)?.doors
@@ -519,7 +544,7 @@ export class AssistantChatResolver {
       const stored = await messageRepo.save({
         session: { id: session.id } as any,
         role: 'assistant',
-        content: result.reply,
+        content: reply,
         /*
          * 이 답이 지나온 문을 함께 적는다 — ADR-0073 판정 1. 방은 도메인 안에서 공개이므로, 이 문장이
          * 실어 나르는 값을 나중에 읽는 사람이 열 수 있는지 판정할 근거가 행에 있어야 한다. 적지 않으면
@@ -543,7 +568,7 @@ export class AssistantChatResolver {
         kind: 'message',
         anchorType: (session as any).anchorType,
         anchorId: (session as any).anchorId,
-        preview: result.reply,
+        preview: reply,
         actorId: user?.id
       })
 
@@ -551,7 +576,7 @@ export class AssistantChatResolver {
         aiClientId: client.id,
         agentId: client.agent.id,
         updater: user,
-        ...activityPatch(result.reply, new Date(), answerDoors)
+        ...activityPatch(reply, new Date(), answerDoors)
       } as any)
 
       /*
@@ -573,7 +598,8 @@ export class AssistantChatResolver {
     }
 
     return {
-      reply: result.reply,
+      reply,
+      suggestion: suggestion ?? null,
       clientId: client.id,
       agentId: client.agent.id,
       sessionId: session?.id,

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

@@ -12,7 +12,7 @@ import { GraphQLJSON } from 'graphql-scalars'
 import '@things-factory/auth-base'
 
 import { assistantModeView } from './resolve.js'
-import { assistantModesForSubject } from './registry.js'
+import { assistantModeForSubject } from './registry.js'
 import { requestTranslator } from '../request-translator.js'
 
 @ObjectType({ description: 'One `/` sentence, in the words of this request.' })
@@ -63,45 +63,32 @@ class AssistantModeView {
   attachments?: any
 }
 
-@ObjectType({ description: 'A conversation a screen may open for what it is showing.' })
+@ObjectType({ description: 'The conversation a screen opens for what it is showing.' })
 class AssistantModeChoice {
   @Field({ description: 'The mode kind to open.' })
   kind: string
 
-  @Field({ description: 'What to call it where a person chooses — already in the words of this request.' })
+  @Field({ description: 'What the conversation is called in the conversation list, in the words of this request.' })
   label: string
-
-  @Field({ description: 'Whether this is the one to open when the person has not chosen.' })
-  isDefault: boolean
 }
 
 @Resolver()
 export class AssistantModeResolver {
   /*
-   * 이 화면이 보여 주는 것으로 열 수 있는 대화들 — ADR-0072 A17 ①.
-   *
-   * 화면은 자기가 무엇을 보여 주는지(`subject`)만 안다. 그 위에 어느 대화가 서는지는 앱 서버가
-   * 선언한다. 화면이 종류 목록을 손으로 들고 있으면, 대화를 하나 더 세운 날 그 화면만 모른 채로 남는다.
+   * 이 화면의 대화 — 화면에 대화 하나(design/ai/screen-pattern.md §3).
    *
-   * 하나만 오면 고르개를 내지 않는다 — 고를 것이 없는 고르개는 자리만 차지한다.
+   * 화면은 자기가 무엇을 보여 주는지(`subject`)만 안다. 그 위에 어느 대화가 서는지는 앱 서버가 선언한다.
    */
-  @Query(() => [AssistantModeChoice], {
-    description:
-      'Conversations that stand for this kind of subject, the default first. A screen showing one subject opens the head of this list and offers the rest; a single entry means there is nothing to choose.'
+  @Query(() => AssistantModeChoice, {
+    nullable: true,
+    description: 'The one conversation for this kind of subject. Null when no application declared one.'
   })
   @Directive('@privilege(category: "ai-assistant", privilege: "query", domainOwnerGranted: true)')
-  async assistantModes(@Arg('subject') subject: string, @Ctx() context: any): Promise<AssistantModeChoice[]> {
+  async assistantModeFor(@Arg('subject') subject: string, @Ctx() context: any): Promise<AssistantModeChoice | null> {
+    const mode = assistantModeForSubject(subject)
+    if (!mode) return null
     const t = requestTranslator(context)
-
-    return assistantModesForSubject(subject).map(mode => ({
-      kind: mode.kind,
-      /*
-       * 이름이 없는 대화는 종류를 그대로 쓴다. 부팅 보고가 이미 그것을 경고로 말하므로 여기서 숨기지
-       * 않는다 — 화면에 `twin.space` 가 뜨면 그것이 빠진 선언을 가리킨다.
-       */
-      label: mode.labelKey ? t(mode.labelKey) : mode.kind,
-      isDefault: (mode.defaultFor ?? []).includes(subject)
-    }))
+    return { kind: mode.kind, label: mode.labelKey ? t(mode.labelKey) : mode.kind }
   }
   @Query(() => AssistantModeView, {
     description: 'What this conversation offers on screen — `/` sentences, the `@` catalog and the notices, translated.'

package/server/service/assistant-mode/fallback-subjects.ts

@@ -0,0 +1,36 @@
+/**
+ * The open subjects the shared parts can name without an application's help (design/ai/screen-pattern.md §2-1):
+ * the site (`domain`), an application's home (`application`) and a board (`board`). An application that names
+ * one of these differently registers its own describer, which is read first.
+ *
+ * A board is read by entity name: the board entity belongs to board-service, and this package does not depend on
+ * it. A deployment without boards has no board anchors, and a read that fails says the subject could not be read.
+ */
+import { Domain, getRepository } from '@things-factory/shell'
+import { registerFallbackSubject } from '@things-factory/ai-client-base'
+
+registerFallbackSubject({
+  anchorType: 'domain',
+  async describe({ anchorId, domain }) {
+    /* The site of this conversation only - another domain's name is not this person's to read. */
+    if (anchorId !== domain.id) return undefined
+    const found = await getRepository(Domain).findOne({ where: { id: anchorId } })
+    return found ? { noun: 'site', name: found.description || found.name } : undefined
+  }
+})
+
+registerFallbackSubject({
+  anchorType: 'application',
+  async describe({ anchorId }) {
+    /* The application's home is a place, not a record: nothing narrower is open. */
+    return { noun: 'home of the application', name: anchorId }
+  }
+})
+
+registerFallbackSubject({
+  anchorType: 'board',
+  async describe({ anchorId, domain }) {
+    const found: any = await getRepository('Board').findOne({ where: { id: anchorId, domain: { id: domain.id } } })
+    return found?.name ? { noun: 'board', name: found.name } : undefined
+  }
+})

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

@@ -7,10 +7,11 @@ export {
   registerAssistantMode,
   getAssistantMode,
   listAssistantModes,
-  assistantModesForSubject,
+  assistantModeForSubject,
   getAssistantModeWarnings,
   clearAssistantModes
 } from './registry.js'
 export { resolveModeSettings, assistantModeView } from './resolve.js'
+export { ABSENCE_RULE, NEXT_REQUEST_RULE, conversationPrompt, splitNextRequest } from './screen-rules.js'
 export type { AssistantModeSpec, AssistantModeSlash, AssistantModeWarning } from './types.js'
 export type { AssistantModeRef, ModeSettings, AssistantModeView, AssistantModeSlashView, Translate } from './resolve.js'

package/server/service/assistant-mode/one-conversation-per-subject.test.ts

@@ -0,0 +1,37 @@
+/*
+ * A screen has one conversation (operato-application design/ai/screen-pattern.md §3).
+ *
+ * Two conversations on one subject put a picker in front of the person, a choice between our internal units. The
+ * boot report names the subject instead, and the screen opens the one conversation for what it shows.
+ */
+import { assistantModeForSubject, clearAssistantModes, getAssistantModeWarnings, registerAssistantMode } from './registry'
+
+const persona = 'you are here'
+
+describe('assistant mode — one conversation per subject', () => {
+  beforeEach(() => clearAssistantModes())
+  afterAll(() => clearAssistantModes())
+
+  it('★ two conversations on one subject is a boot warning naming both', () => {
+    registerAssistantMode({ kind: 'twin.board', systemPrompt: persona, subjects: ['board'] })
+    registerAssistantMode({ kind: 'twin.space', systemPrompt: persona, subjects: ['space', 'board'] })
+
+    const twice = getAssistantModeWarnings().filter(w => w.code === 'assistant-mode-subject-claimed-twice')
+    expect(twice.map(w => w.params.subject)).toEqual(['board'])
+    expect(twice[0].params.kinds).toEqual(['twin.board', 'twin.space'])
+  })
+
+  it('one conversation on each subject says nothing', () => {
+    registerAssistantMode({ kind: 'twin.board', systemPrompt: persona, subjects: ['board'] })
+    registerAssistantMode({ kind: 'twin.space', systemPrompt: persona, subjects: ['space'] })
+
+    expect(getAssistantModeWarnings()).toEqual([])
+  })
+
+  it('★ a screen opens the conversation for its subject, and nothing for a subject nobody declared', () => {
+    registerAssistantMode({ kind: 'plant.station', systemPrompt: persona, subjects: ['station'] })
+
+    expect(assistantModeForSubject('station')?.kind).toBe('plant.station')
+    expect(assistantModeForSubject('nothing-shows-this')).toBeUndefined()
+  })
+})

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

@@ -0,0 +1,29 @@
+/*
+ * The door says what is open from the stored anchor (operato-application design/ai/screen-pattern.md §2-1 · §4-1).
+ */
+import { readFileSync } from 'fs'
+import { join } from 'path'
+
+const door = readFileSync(join(__dirname, '../assistant-chat-resolver.ts'), 'utf8')
+
+describe('the door', () => {
+  it('★ builds the line from the stored session anchor every turn, never from what the screen sent', () => {
+    const block = door.slice(door.indexOf('const subjectLine = session'), door.indexOf('const systemPrompt = subjectLine'))
+    expect(block).toMatch(/anchorType: \(session as any\)\.anchorType/)
+    expect(block).toMatch(/anchorId: \(session as any\)\.anchorId/)
+    expect(block).not.toMatch(/hostContext/)
+  })
+
+  it('★ the model and the grounding check both read the prompt with the line', () => {
+    expect(door.match(/^\s+systemPrompt,$/gm)).toHaveLength(2)
+    expect(door).not.toMatch(/systemPrompt: settings\.systemPrompt/)
+  })
+
+  it('★ the stored answer, the list preview and the reply leave out the Next: line', () => {
+    expect(door).toMatch(/const \{ reply, suggestion \} = splitNextRequest\(result\.reply\)/)
+    expect(door).toMatch(/content: reply,/)
+    expect(door).toMatch(/preview: reply,/)
+    expect(door).toMatch(/activityPatch\(reply, /)
+    expect(door).not.toMatch(/content: result\.reply/)
+  })
+})

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

@@ -62,47 +62,20 @@ export function getAssistantModeWarnings(): ReadonlyArray<AssistantModeWarning>
   const out: AssistantModeWarning[] = []
 
   /*
-   * 한 화면이 어느 대화를 기본으로 여는가 — 등록 순서로 정하지 않는다(ADR-0072 A17 ②). 없으면 화면이
-   * 무엇을 열지 모르고, 둘이면 마지막에 부팅한 모듈이 조용히 이긴다. 둘 다 여기서 말한다.
+   * 한 화면에 대화 하나 — design/ai/screen-pattern.md §3. 같은 subject 를 두 대화가 적으면 화면은 어느 쪽을
+   * 열지 모르고, 고르개로 사람에게 넘기면 원칙 3 을 어긴다. 성격이 다른 물음은 그 대화가 도구를 더 연다.
    */
-  const defaults = new Map<string, string[]>()
-  const claimed = new Set<string>()
+  const owners = new Map<string, string[]>()
   for (const mode of modes.values()) {
-    for (const subject of mode.subjects ?? []) claimed.add(subject)
-    for (const subject of mode.defaultFor ?? []) {
-      defaults.set(subject, [...(defaults.get(subject) ?? []), mode.kind])
-    }
+    for (const subject of mode.subjects ?? []) owners.set(subject, [...(owners.get(subject) ?? []), mode.kind])
   }
-  for (const subject of claimed) {
-    const owners = defaults.get(subject) ?? []
-    if (owners.length === 0) {
-      out.push({
-        code: 'assistant-mode-subject-without-default',
-        params: { kind: '', subject },
-        message: `no conversation is the default for subject '${subject}' — a screen showing it has nothing to open`
-      })
-    } else if (owners.length > 1) {
-      out.push({
-        code: 'assistant-mode-subject-default-twice',
-        params: { kind: owners[0], subject, kinds: owners },
-        message: `subject '${subject}' has more than one default (${owners.join(', ')}) — boot order would decide it`
-      })
-    }
-  }
-
-  for (const mode of modes.values()) {
-    /*
-     * 고를 수 있는 대화에는 부를 이름이 있어야 한다 — 고르개에 종류 이름(`twin.space`)이 뜨면 그것은
-     * 우리 내부 단위를 사람에게 떠넘기는 것이다.
-     */
-    const shared = (mode.subjects ?? []).some(subject => countModesFor(subject) > 1)
-    if (shared && !mode.labelKey) {
-      out.push({
-        code: 'assistant-mode-offered-without-label',
-        params: { kind: mode.kind },
-        message: `mode '${mode.kind}' can be offered beside another on the same subject but has no labelKey`
-      })
-    }
+  for (const [subject, kinds] of owners) {
+    if (kinds.length < 2) continue
+    out.push({
+      code: 'assistant-mode-subject-claimed-twice',
+      params: { kind: kinds[0], subject, kinds },
+      message: `subject '${subject}' has more than one conversation (${kinds.join(', ')}) — a screen has one conversation; open more tools in one of them`
+    })
   }
 
   for (const mode of modes.values()) {
@@ -135,23 +108,9 @@ export function getAssistantModeWarnings(): ReadonlyArray<AssistantModeWarning>
   return out
 }
 
-/** 이 subject 종류에 서는 대화가 몇인가 — 고르개가 필요한지, 이름이 필요한지를 가른다. */
-function countModesFor(subject: string): number {
-  let count = 0
-  for (const mode of modes.values()) {
-    if ((mode.subjects ?? []).includes(subject)) count++
-  }
-  return count
-}
-
-/**
- * 이 subject 종류에 서는 대화들 — 등록 순서대로, 기본이 먼저.
- *
- * 화면은 이 목록으로 고르개를 낸다. 하나뿐이면 고르개를 내지 않는다(ADR-0072 A17 ①).
- */
-export function assistantModesForSubject(subject: string): ReadonlyArray<AssistantModeSpec> {
-  const standing = [...modes.values()].filter(mode => (mode.subjects ?? []).includes(subject))
-  return standing.sort((a, b) => Number((b.defaultFor ?? []).includes(subject)) - Number((a.defaultFor ?? []).includes(subject)))
+/** The conversation a screen showing this kind of subject opens — one per subject (design/ai/screen-pattern.md §3). */
+export function assistantModeForSubject(subject: string): AssistantModeSpec | undefined {
+  return [...modes.values()].find(mode => (mode.subjects ?? []).includes(subject))
 }
 
 /** Test only. */

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

@@ -8,6 +8,7 @@
  */
 import { clearAssistantModes, registerAssistantMode } from './registry'
 import { assistantModeView, resolveModeSettings } from './resolve'
+import { ABSENCE_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}` : ''})`
@@ -32,7 +33,8 @@ it('★ the settings come from the registered mode', () => {
   const settings = resolveModeSettings({ kind: 'twin.space', target: 'S-12' }, t)
 
   expect(settings).toEqual({
-    systemPrompt: 'you answer about one space',
+    /* The app's persona, then the rules every conversation follows (design/ai/screen-pattern.md §4). */
+    systemPrompt: conversationPrompt('you answer about one space'),
     /* Every conversation may put a large result on the AI 작업판 (design/ai/workspace.md). */
     toolCategories: ['twin-ops', 'assistant-workspace'],
     requireToolOnFirstTurn: true,
@@ -41,6 +43,13 @@ it('★ the settings come from the registered mode', () => {
   })
 })
 
+it('★ every conversation carries the absence rule and the next-request rule once, after its persona', () => {
+  const { systemPrompt } = resolveModeSettings({ kind: 'twin.space' }, t)
+  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)
+})
+
 it('★ an unregistered kind is refused — no plain-conversation fallback', () => {
   expect(() => resolveModeSettings({ kind: 'twin.nothing' }, t)).toThrow(/t\(ai-assistant.text.unknown-mode\)/)
   try {

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

@@ -6,6 +6,7 @@ import type { AttachmentPolicy } from '../chat-session/attachment-policy.js'
  * the server would answer differently.
  */
 import { getAssistantMode } from './registry'
+import { conversationPrompt } from './screen-rules'
 import type { AssistantModeSlash } from './types'
 
 export type Translate = (key: string, params?: Record<string, any>) => string
@@ -65,7 +66,8 @@ export function resolveModeSettings(ref: AssistantModeRef, t: Translate): ModeSe
   if (!mode) throw unknownModeError(kind, t)
 
   return {
-    systemPrompt: mode.systemPrompt,
+    /* The app's persona, with the rules every conversation follows (design/ai/screen-pattern.md §4). */
+    systemPrompt: conversationPrompt(mode.systemPrompt),
     /* A mode that takes attachments can open the files sent in earlier turns (design/ai/shared-dock.md §9-4). */
     toolCategories: modeToolCategories(mode),
     requireToolOnFirstTurn: mode.requireToolOnFirstTurn,

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

@@ -0,0 +1,39 @@
+/*
+ * The rules every conversation follows (operato-application design/ai/screen-pattern.md §4).
+ */
+import { ABSENCE_RULE, NEXT_REQUEST_RULE, conversationPrompt, splitNextRequest } from './screen-rules'
+
+describe('the next request an answer names', () => {
+  it('★ the last line is taken off the reply and becomes the suggestion', () => {
+    expect(splitNextRequest('The fan has 3 blades.\n\nNext: 날개를 5개로 늘려 줘')).toEqual({
+      reply: 'The fan has 3 blades.',
+      suggestion: '날개를 5개로 늘려 줘'
+    })
+  })
+
+  it('quotes and bold around the line are not part of the request', () => {
+    expect(splitNextRequest('Done.\n**Next:** "재질을 바꿔 줘"').suggestion).toBe('재질을 바꿔 줘')
+  })
+
+  it('★ a Next: that is not the last line is part of the answer', () => {
+    const reply = 'Next: we read the figure.\nIt has 3 blades.'
+    expect(splitNextRequest(reply)).toEqual({ reply })
+  })
+
+  it('a reply with no such line has no suggestion', () => {
+    expect(splitNextRequest('It has 3 blades.')).toEqual({ reply: 'It has 3 blades.' })
+  })
+
+  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', () => {
+    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))
+  })
+})

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

@@ -0,0 +1,47 @@
+/**
+ * The rules every conversation follows, whatever app declared it (operato-application design/ai/screen-pattern.md).
+ *
+ * Five apps carried their own copy of the absence rule, word for word or nearly. A rule every conversation needs
+ * belongs to the door that builds every conversation's prompt, so an app's prompt says only who the assistant is
+ * there and what it may not claim.
+ *
+ * Model-facing text is English (the AI standard's A11); the person's language comes from the request.
+ */
+
+/** §4-2 — an absence or a refusal is a fact, with what the person can do. */
+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.'
+
+/** 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 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')
+}
+
+/**
+ * The reply without its `Next:` line, and the request that line named.
+ *
+ * Only the last non-empty line counts: a `Next:` in the middle of an answer is part of the answer. The line is
+ * taken off before the reply is stored, so a conversation read later shows the answer alone.
+ */
+export function splitNextRequest(reply: string): { reply: string; suggestion?: string } {
+  const text = String(reply ?? '')
+  const lines = text.replace(/\s+$/, '').split('\n')
+  const last = lines[lines.length - 1] ?? ''
+  const match = /^\s*(?:\*\*)?Next:(?:\*\*)?\s*(.+?)\s*$/.exec(last)
+  if (!match) return { reply: text }
+
+  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 }
+}

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

@@ -29,32 +29,15 @@ export interface AssistantModeSpec {
   kind: string
 
   /**
-   * Which kinds of subject this conversation stands for — `['board', 'space']` (ADR-0072 A17 ①).
+   * Which kinds of subject this conversation is for — `['board']`, `['space']`.
    *
-   * A screen says what it is showing (`context.subject`), and these say which conversations that
-   * subject can carry. It is a list of types and not a predicate on purpose: a list can be counted
-   * at boot and pinned by a test, while a function can only be run.
-   *
-   * On the twin modeller nothing could be asked about operations, because an open board pinned the
-   * authoring conversation and that conversation opens one category. A conversation that also
-   * stands for `board` is how the same screen carries both.
+   * A screen says what it is showing (`context.subject`) and opens the one conversation for it: a screen has one
+   * conversation (design/ai/screen-pattern.md §3). A list of types, so it can be counted at boot and pinned by a
+   * test; two modes naming one subject is a boot warning.
    */
   subjects?: string[]
 
-  /**
-   * The conversation a screen opens when the person has not chosen — one per subject type
-   * (ADR-0072 A17 ②).
-   *
-   * Registration order must not decide this: whichever module booted last would silently become
-   * the default. Exactly one mode declares each subject type, and the boot report says so when a
-   * type has none or more than one.
-   */
-  defaultFor?: string[]
-
-  /**
-   * i18n key for what this conversation is called where a person chooses between them —
-   * "이 그림 고치기", "이 현장 지금 어때". A mode a screen may offer needs one.
-   */
+  /** i18n key for what this conversation is called in the conversation list. */
   labelKey?: string
   /** Who the assistant is here, and what it must not claim to do. The server's, not the caller's. */
   systemPrompt: string
@@ -118,16 +101,10 @@ export interface AssistantModeSpec {
 export interface AssistantModeWarning {
   /**
    * `assistant-mode-slash-outside-tools` — a `/` sentence needs a tool this mode does not open.
-   * `assistant-mode-subject-without-default` — a subject type no conversation claims as its default.
-   * `assistant-mode-subject-default-twice` — two conversations claim the same subject type.
-   * `assistant-mode-offered-without-label` — a conversation a screen may offer with nothing to call it.
+   * `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.
    */
-  code:
-    | 'assistant-mode-slash-outside-tools'
-    | 'assistant-mode-subject-without-default'
-    | 'assistant-mode-subject-default-twice'
-    | 'assistant-mode-offered-without-label'
-    | 'assistant-mode-entry-target-unknown'
+  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 }
   /** For a person reading the boot log; callers act on the code and params. */
   message: string