@things-factory/ai-assistant 10.1.26 → 10.1.28

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

@@ -0,0 +1,288 @@
+/*
+ * A conversation with several people in it, written as a script, so a test can say what the
+ * assistant should have heard and what it should have done.
+ *
+ * ── Why a harness (standard A15) ───────────────────────────────────────────────
+ * A shared session carries two kinds of talk: people talking to each other, and people talking to
+ * the assistant. Everything a person types is stored the same way, and the model reads all of it.
+ * So the questions a test must be able to ask are:
+ *
+ *   누가 말했나 · 누구에게 한 말인가 · 그 턴에 모델을 불렀나 · 모델이 무엇을 읽었나 ·
+ *   무엇을 쓸 수 있었나 · 답과 제안은 누구 것인가
+ *
+ * Those are hard to see from a resolver test, because the interesting part is what the model was
+ * handed — and that is a string built from stored rows. The script keeps the rows, builds the same
+ * history the door builds, and records every model call.
+ *
+ * ── What this does not do ──────────────────────────────────────────────────────
+ * No database, no GraphQL, no provider. It drives the same two pieces the door drives
+ * (`buildLlmHistory` and `registryAssistantChat`) with a recording client, so a failure names a
+ * rule rather than a stack. Anything that only the resolver does — storing, broadcasting, session
+ * activity — is out of scope here and belongs in a resolver test.
+ */
+import { registryAssistantChat } from '@things-factory/ai-client-base'
+
+import { buildLlmHistory, type HistoryRow } from '../chat-message/llm-history.js'
+import { formatProposalOutcomeLine, type ProposalOutcome } from '../chat-message/proposal-outcome.js'
+import { roomMessageBody } from '../chat-message/room-message.js'
+import { inviteMentionedUsers } from '../chat-session-participant/mention-invite.js'
+
+/** Who a turn was meant for. The room hears everything; only the assistant answers. */
+export type Addressee = 'room' | 'assistant'
+
+export interface ScriptedTurn {
+  speaker: string
+  addressee: Addressee
+  content: string
+  /** `mention` 이 부른 사람 — 본문에는 마커로 실린다. */
+  mentions?: string[]
+  /** 호스트가 카드에 답한 것 — 사람의 말이 아니라 기록이다. */
+  outcome?: { proposalKey: string; outcome: ProposalOutcome }
+}
+
+/** One model call, exactly as the provider saw it. */
+export interface RecordedCall {
+  systemPrompt: string
+  /** The conversation handed over, newest last. */
+  messages: { role: string; content: any }[]
+  /** Tool names offered this turn. */
+  tools: string[]
+}
+
+export interface ScriptResult {
+  /** Every model call, in order. A room turn must not produce one. */
+  calls: RecordedCall[]
+  /** What the assistant answered, one per `ask`. */
+  replies: string[]
+  /** Proposals returned, paired with the turn that asked for them. */
+  proposals: { askedBy: string; proposal: any }[]
+  /** The rows as they stand, in the order they were said. */
+  rows: HistoryRow[]
+  /** Who is in the room now, and what each of them may do. */
+  participants: ScriptParticipant[]
+  /** What each `mention` did — who joined, or why nobody did. */
+  invites: { by: string; invited: string[]; notSeated?: string[] }[]
+}
+
+/** A person in the room. `read` is how far they have read — the fact others see as a badge. */
+export interface ScriptParticipant {
+  userId: string
+  role: 'owner' | 'member' | 'viewer'
+  read?: number
+}
+
+/** A provider that answers with a fixed script and records what it was given. */
+export interface RecordingModel {
+  client: any
+  calls: RecordedCall[]
+}
+
+/**
+ * A model that answers each call with the next canned reply, and records what it saw.
+ *
+ * `toolCalls` lets a script make the model ask for a tool on a given turn — the harness then
+ * exercises the dispatch path rather than only the prompt.
+ */
+export function recordingModel(
+  replies: string[] = ['ok'],
+  toolCalls: { name: string; arguments?: any }[][] = []
+): RecordingModel {
+  const calls: RecordedCall[] = []
+  let turn = 0
+  let replyTurn = 0
+
+  const client = {
+    id: 'recording:test',
+    async chatWithTools(messages: any[], tools: any[], options: any) {
+      const index = turn++
+      calls.push({
+        systemPrompt: options?.systemPrompt ?? '',
+        messages: messages.map(m => ({ role: m.role, content: m.content })),
+        tools: (tools ?? []).map(t => t.name)
+      })
+      /* The loop asks again after a tool answers, so only the first call of a turn asks for tools. */
+      const wanted = toolCalls[index] ?? []
+      if (wanted.length > 0) {
+        return {
+          text: '',
+          toolCalls: wanted.map((c, i) => ({ id: `call-${index}-${i}`, name: c.name, arguments: c.arguments ?? {} })),
+          stopReason: 'tool_use'
+        }
+      }
+      return { text: replies[Math.min(replyTurn++, replies.length - 1)] ?? 'ok', toolCalls: [], stopReason: 'end_turn' }
+    }
+  }
+
+  return { client, calls }
+}
+
+export interface ConversationOptions {
+  /**
+   * Who is in the room when the script starts, and as what.
+   *
+   * A conversation always has an owner — the person who started it — and `createAISession` puts
+   * them there. Since ADR-0073 a mention grants nothing, so the roster no longer decides who may
+   * name whom; it still decides who the room reaches and who is already seated.
+   */
+  participants?: ScriptParticipant[]
+  /** 이 대화가 공개인가 — 기본은 공개(ADR-0073 판정 2). 'private' 이면 멘션이 사람을 앉히지 않는다. */
+  visibility?: 'open' | 'private'
+  /** Who the assistant is on this surface — in real use it comes from the registered mode. */
+  systemPrompt?: string
+  /** Which registered categories this conversation may use. Omitted allows none. */
+  toolCategories?: string[]
+  /** Request state the tools receive (domain, user). */
+  state?: any
+  /** What the surface is looking at — reaches tools as `ctx.host`, never the model. */
+  hostContext?: any
+  /** Passed through to the runner; a live-state surface makes the model read first. */
+  requireToolOnFirstTurn?: boolean
+}
+
+/**
+ * Write the conversation, then run it.
+ *
+ * ```ts
+ * const result = await conversation({ toolCategories: ['twin-ops'] })
+ *   .say('alice', '3 라인이 멈춘 것 같아요')
+ *   .say('bob', '아까부터 그랬어')
+ *   .ask('alice', '왜 멈췄는지 확인해줘')
+ *   .run(recordingModel(['확인했습니다']))
+ * ```
+ */
+export function conversation(options: ConversationOptions = {}) {
+  const turns: ScriptedTurn[] = []
+
+  const api = {
+    /** Someone speaks to the room. Nobody calls the assistant; it reads this next time it is asked. */
+    say(speaker: string, content: string) {
+      turns.push({ speaker, addressee: 'room', content })
+      return api
+    },
+    /** Someone asks the assistant. This is the turn that makes a model call. */
+    ask(speaker: string, content: string) {
+      turns.push({ speaker, addressee: 'assistant', content })
+      return api
+    },
+    /**
+     * Someone asks the assistant **and names a colleague** — the way a second person joins.
+     *
+     * The marker is what the browser puts in the text when a name is picked from `@`, and the door
+     * reads it from the stored turn. Only a person already in the room may bring another in.
+     */
+    mention(speaker: string, userIds: string[], content: string) {
+      const marked = [...userIds.map(id => `@${id}{userId:${id}}`), content].join(' ')
+      turns.push({ speaker, addressee: 'assistant', content: marked, mentions: userIds })
+      return api
+    },
+
+    /** The assistant's own answer, when a script needs one already in the history. */
+    answered(content: string) {
+      turns.push({ speaker: 'assistant', addressee: 'room', content })
+      return api
+    },
+
+    /**
+     * The host says what it did with a proposal — the card's state and the model's next turn both
+     * read this row (ADR-0070 A12-a).
+     */
+    outcome(proposalKey: string, outcome: ProposalOutcome) {
+      turns.push({ speaker: 'system', addressee: 'room', content: '', outcome: { proposalKey, outcome } })
+      return api
+    },
+
+    async run(model: RecordingModel = recordingModel()): Promise<ScriptResult> {
+      const rows: HistoryRow[] = []
+      const replies: string[] = []
+      const proposals: { askedBy: string; proposal: any }[] = []
+      const invites: { by: string; invited: string[]; notSeated?: string[] }[] = []
+
+      /* 참여자 저장소 — 실제 문이 쓰는 것과 같은 규칙을 지나되, 기억에만 둔다. */
+      const roster: any[] = (options.participants ?? [{ userId: 'alice', role: 'owner' }]).map((person, index) => ({
+        id: `participant-${index + 1}`,
+        userId: person.userId,
+        role: person.role,
+        read: person.read
+      }))
+      const participants = {
+        find: async () => roster,
+        save: async (row: any) => {
+          roster.push({ id: `participant-${roster.length + 1}`, userId: row.user.id, role: row.role })
+        },
+        update: async (id: string, patch: any) => {
+          const found = roster.find(row => row.id === id)
+          if (found) Object.assign(found, patch)
+        }
+      }
+
+      for (const turn of turns) {
+        /* 호스트의 답은 사람의 말이 아니다 — 서버가 쓰는 `system` 행이다. */
+        if (turn.outcome) {
+          rows.push({
+            id: `row-${rows.length + 1}`,
+            role: 'system',
+            content: formatProposalOutcomeLine(turn.outcome.proposalKey, turn.outcome.outcome)
+          })
+          continue
+        }
+
+        /* 빈 말은 저장되지 않는다 — 문이 지키는 규칙과 같은 것을 쓴다. */
+        const body = roomMessageBody(turn.content)
+        if (!body) continue
+
+        rows.push({
+          id: `row-${rows.length + 1}`,
+          role: turn.speaker === 'assistant' ? 'assistant' : 'user',
+          content: body,
+          senderId: turn.speaker,
+          senderName: turn.speaker,
+          /* 사람의 말에만 대상이 있다 — 문이 찍는 값과 같은 자리다(ADR-0070 A15 결정 ①). */
+          addressee: turn.speaker === 'assistant' ? undefined : turn.addressee
+        })
+
+        /* 멘션은 사람의 말을 저장하는 문에서만 사람을 불러들인다(ADR-0071 결정 1 ①). */
+        if (turn.speaker !== 'assistant') {
+          const invite = await inviteMentionedUsers({
+            content: body,
+            sessionId: 'script-session',
+            domainId: 'script-domain',
+            inviter: { id: turn.speaker },
+            participants,
+            visibility: options.visibility
+          })
+          if (invite.invited.length > 0 || invite.notSeated) {
+            invites.push({ by: turn.speaker, invited: invite.invited, notSeated: invite.notSeated })
+          }
+        }
+
+        /* Only a turn addressed to the assistant runs it. Room talk is context for the next one. */
+        if (turn.addressee !== 'assistant') continue
+
+        const result = await registryAssistantChat({
+          client: model.client,
+          messages: buildLlmHistory(rows, {}) as any,
+          systemPrompt: options.systemPrompt ?? 'you are a test assistant',
+          toolCategories: options.toolCategories,
+          hostContext: options.hostContext,
+          state: options.state ?? { domain: { id: 'dom-1' }, user: { id: 'u-1' } },
+          requireToolOnFirstTurn: options.requireToolOnFirstTurn
+        })
+
+        replies.push(result.reply)
+        rows.push({ id: `row-${rows.length + 1}`, role: 'assistant', content: result.reply })
+        for (const proposal of result.loop.proposals ?? []) proposals.push({ askedBy: turn.speaker, proposal })
+      }
+
+      return {
+        calls: model.calls,
+        replies,
+        proposals,
+        rows,
+        participants: roster.map(row => ({ userId: row.userId, role: row.role, read: row.read })),
+        invites
+      }
+    }
+  }
+
+  return api
+}

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

@@ -0,0 +1,107 @@
+/*
+ * 등록된 모드가 **선언한 대로 도는가** — 글자가 아니라 문을 지나서 본다.
+ *
+ * 모드 선언은 소스에 적힌 값이고, 사람이 만나는 것은 그 값이 문을 지나 만들어 낸 것이다. 그 둘이
+ * 어긋나는 자리가 오늘 하루에만 여럿 나왔다: 범주에 없는 도구를 프롬프트가 부르라고 했고, 키는 있는데
+ * 번역이 없었고, 부품에 규칙이 있는데 부르는 쪽이 없었다. 전부 「선언은 맞는데 돌지 않는」 모양이다.
+ *
+ * 그래서 앱의 시험이 이것으로 **자기 모드를 실제로 돌려 본다**:
+ *   · 그 이름으로 모드가 서는가
+ *   · 그 모드가 여는 도구가 무엇인가 — 모델에게 실제로 건네지는 목록
+ *   · 첫 턴 도구 호출을 강제하는가
+ *   · 화면에 낼 말이 **키가 아니라 문장**으로 나오는가
+ *   · 슬래시가 가리키는 도구가 그 모드 안에 있는가
+ */
+import { registryAssistantChat } from '@things-factory/ai-client-base'
+
+import { getAssistantMode, getAssistantModeWarnings } from '../assistant-mode/registry.js'
+import { assistantModeView, resolveModeSettings, type Translate } from '../assistant-mode/resolve.js'
+
+export interface ModeRunResult {
+  /** 이 모드가 모델에게 실제로 건넨 도구 이름. */
+  offeredTools: string[]
+  /** 모델이 받은 시스템 프롬프트 — 서버의 것인지 확인할 수 있다. */
+  systemPrompt: string
+  /** 첫 턴에 도구를 강제했는가. */
+  requiredToolOnFirstTurn: boolean
+  reply: string
+}
+
+/** 시험용 번역기 — 키를 그대로 돌려준다. 문장이 나와야 할 자리에 키가 나오면 눈에 띈다. */
+export const keyEchoTranslate: Translate = key => key
+
+/**
+ * 등록된 모드로 한 턴을 돌린다 — 프롬프트도 도구도 **등록에서** 나온다.
+ *
+ * 시험이 자기 값을 넘기면 그 시험은 선언을 안 본 것이다. 그래서 여기서는 `kind` 만 받는다.
+ */
+export async function runRegisteredMode(
+  kind: string,
+  options: { client: any; hostContext?: any; state?: any; toolAccess?: any; reply?: string } = {} as any
+): Promise<ModeRunResult> {
+  const settings = resolveModeSettings({ kind }, keyEchoTranslate)
+  let requiredToolOnFirstTurn = false
+
+  const result = await registryAssistantChat({
+    client: options.client,
+    messages: [{ role: 'user', content: '한 턴' }] as any,
+    systemPrompt: settings.systemPrompt,
+    toolCategories: settings.toolCategories,
+    requireToolOnFirstTurn: (requiredToolOnFirstTurn = Boolean(settings.requireToolOnFirstTurn)),
+    model: settings.model,
+    temperature: settings.temperature,
+    maxTokens: settings.maxTokens,
+    hostContext: options.hostContext,
+    toolAccess: options.toolAccess,
+    state: options.state ?? { domain: { id: 'dom-1' }, user: { id: 'u-1' } }
+  })
+
+  return {
+    offeredTools: [...result.offeredTools],
+    systemPrompt: settings.systemPrompt,
+    requiredToolOnFirstTurn,
+    reply: result.reply
+  }
+}
+
+export interface ModeWording {
+  placeholder?: string
+  slash: { name: string; description: string; template: string }[]
+  footerNotice?: string
+  stagedNotice?: string
+}
+
+/** 화면에 낼 말 — 주어진 사전으로 옮긴 결과. 키가 그대로 남으면 사전에 없는 것이다. */
+export function modeWording(kind: string, dictionary: Record<string, string>): ModeWording {
+  const view = assistantModeView(kind, key => dictionary[key] ?? key)
+  return {
+    placeholder: view.placeholder,
+    slash: view.slashTemplates,
+    footerNotice: view.footerNotice,
+    stagedNotice: view.stagedNotice
+  }
+}
+
+/** 사전에 없어서 키가 그대로 화면에 나갈 말들. 비어 있어야 한다. */
+export function missingWording(kind: string, dictionary: Record<string, string>): string[] {
+  const missing: string[] = []
+  const spec = getAssistantMode(kind)
+  if (!spec) return [`mode:${kind}`]
+
+  for (const key of [spec.placeholderKey, spec.footerNoticeKey, spec.stagedNoticeKey]) {
+    if (key && !(key in dictionary)) missing.push(key)
+  }
+  for (const slash of spec.slashTemplates ?? []) {
+    for (const key of [slash.descriptionKey, slash.templateKey]) {
+      if (!(key in dictionary)) missing.push(key)
+    }
+  }
+  return missing
+}
+
+/** 이 모드가 자기 도구로 못 하는 일을 제안하는가 — 부팅 보고와 같은 답. */
+export function modePromisesItCannotKeep(kind: string): string[] {
+  return getAssistantModeWarnings()
+    .filter(warning => warning.params.kind === kind)
+    .map(warning => `${warning.code}:${warning.params.slash}→${warning.params.tool}`)
+}

package/server/tool-registry-boot-report.ts

@@ -1,5 +1,8 @@
 /*
- * At boot, say which registered tools are not yet what the tool contract requires (A1 stage one).
+ * At boot, say what registered but is not yet what the contracts require — tools with no privilege
+ * (A1 stage one) and modes offering `/` sentences their tools cannot answer (ADR-0058 decision 3).
+ *
+ * One window, because it is one question: what state is this deployment's AI in (standard A7-a).
  *
  * Registration no longer refuses a tool that changes something without declaring its privilege —
  * refusing would stop apps whose tools predate the field. The registry records each omission as a
@@ -10,17 +13,37 @@
 import { logger } from '@things-factory/env'
 import { getToolRegistryWarnings, type ToolRegistryWarning } from '@things-factory/ai-client-base'
 
+import { getAssistantModeWarnings, type AssistantModeWarning } from './service/assistant-mode/index.js'
+
 /** One line per code: the code, how many, and which tools. Empty when there is nothing to report. */
 export function formatToolRegistryWarnings(warnings: ReadonlyArray<ToolRegistryWarning>): string[] {
   const byCode = new Map<string, string[]>()
   for (const warning of warnings) {
     const tools = byCode.get(warning.code) ?? []
-    tools.push(`${warning.params.category}/${warning.params.tool}(${warning.params.kind})`)
+    /* 문 이름이 있으면 함께 적는다 — 「어느 문이 아직 선언이 없나」가 다음에 할 일이다. */
+    const doors = warning.params.doors?.length ? ` → ${warning.params.doors.join(' + ')}` : ''
+    tools.push(`${warning.params.category}/${warning.params.tool}(${warning.params.kind})${doors}`)
     byCode.set(warning.code, tools)
   }
   return [...byCode].map(([code, tools]) => `[ai-assistant] ${code} ×${tools.length}: ${tools.join(', ')}`)
 }
 
+/** One line per code: the code, how many, and which modes promised what. */
+export function formatAssistantModeWarnings(warnings: ReadonlyArray<AssistantModeWarning>): string[] {
+  const byCode = new Map<string, string[]>()
+  for (const warning of warnings) {
+    const offers = byCode.get(warning.code) ?? []
+    offers.push(`${warning.params.kind}:/${warning.params.slash}→${warning.params.tool}`)
+    byCode.set(warning.code, offers)
+  }
+  return [...byCode].map(([code, offers]) => `[ai-assistant] ${code} ×${offers.length}: ${offers.join(', ')}`)
+}
+
+/*
+ * After every module has registered: a mode may declare its slash sentences before the package
+ * that registers the tools they need, so this cannot be checked when the mode registers.
+ */
 process.on('bootstrap-module-start' as any, () => {
   for (const line of formatToolRegistryWarnings(getToolRegistryWarnings())) logger.warn(line)
+  for (const line of formatAssistantModeWarnings(getAssistantModeWarnings())) logger.warn(line)
 })

package/test/assistant-chat-call-sites.test.ts

@@ -0,0 +1,82 @@
+/*
+ * What this guards: nothing sends the conversation's persona, tools, model or limits any more.
+ *
+ * ADR-0061 decision 7 took six fields off `assistantChat` with no compatibility field, on the
+ * condition that a test counts the callers still passing them. Types catch a caller that compiles
+ * against this source; an app compiled against an installed copy, or a hand-written GraphQL
+ * document, would not be caught by anything else.
+ */
+import { readFileSync, readdirSync, statSync } from 'fs'
+import path from 'path'
+
+const PACKAGES = path.resolve(__dirname, '../..')
+const MOVED = ['systemPrompt', 'toolCategories', 'model', 'temperature', 'maxTokens', 'requireGroundingTools']
+
+/** Source files only — a built copy of yesterday's source is not a call site. */
+function sources(dir: string, out: string[] = []): string[] {
+  for (const entry of readdirSync(dir)) {
+    if (entry === 'node_modules' || entry === 'dist-server' || entry === 'dist-client' || entry.startsWith('.')) continue
+    const full = path.join(dir, entry)
+    if (statSync(full).isDirectory()) sources(full, out)
+    else if (/\.(ts|js)$/.test(entry)) out.push(full)
+  }
+  return out
+}
+
+const files = sources(PACKAGES)
+  /* This file names the fields it looks for; counting itself would report itself. */
+  .filter(file => !file.endsWith('assistant-chat-call-sites.test.ts'))
+  .map(file => ({ file, text: readFileSync(file, 'utf-8') }))
+
+it('★ one place builds the neutral door input, and it sends none of the moved fields', () => {
+  const builders = files.filter(f => f.text.includes('buildAssistantChatInput(')).map(f => path.relative(PACKAGES, f.file))
+
+  expect(builders.sort()).toEqual(
+    [
+      'ai-assistant/client/components/assistant-chat.ts',
+      'ai-assistant/client/components/chat-input-builder.test.ts',
+      'ai-assistant/client/components/chat-input-builder.ts'
+    ].sort()
+  )
+
+  const builder = files.find(f => f.file.endsWith('chat-input-builder.ts'))!.text
+  const neutral = builder.slice(builder.indexOf('export function buildAssistantChatInput'))
+  for (const field of MOVED) expect(neutral).not.toContain(`args.${field}`)
+})
+
+it('★ no hand-written document sends the moved fields to assistantChat', () => {
+  const offenders: string[] = []
+  for (const { file, text } of files) {
+    /* The mutation document, wherever it is written. */
+    const at = text.indexOf('assistantChat(input:')
+    if (at < 0) continue
+    const document = text.slice(Math.max(0, at - 2000), at + 2000)
+    for (const field of MOVED) {
+      if (new RegExp(`${field}\\s*:`).test(document)) offenders.push(`${path.relative(PACKAGES, file)} → ${field}`)
+    }
+  }
+
+  expect(offenders).toEqual([])
+})
+
+/*
+ * `model` and `temperature` are left out here on purpose: a board surface passes `.model=` for the
+ * board it is editing, and matching that would report the wrong thing. The door test above covers
+ * them on the wire, which is where they mattered.
+ */
+const ELEMENT_PROPERTIES = ['systemPrompt', 'toolCategories', 'requireGroundingTools']
+
+it('★ no surface in this repo declares a conversation the server should own', () => {
+  const offenders: string[] = []
+  for (const { file, text } of files) {
+    if (!/<ox-assistant-chat/.test(text)) continue
+    if (file.includes('ai-assistant/client/components/')) continue
+    for (const field of ELEMENT_PROPERTIES) {
+      if (new RegExp(`\\.${field}=|${field.replace(/[A-Z]/g, c => '-' + c.toLowerCase())}=`).test(text)) {
+        offenders.push(`${path.relative(PACKAGES, file)} → ${field}`)
+      }
+    }
+  }
+
+  expect(offenders).toEqual([])
+})

package/translations/en.json

@@ -59,12 +59,54 @@
   "ai-assistant.text.ungrounded-mention": "Mentions an unverified target — not present in the actual data:",
   "ai-assistant.text.toggle-system-note": "click to expand",
   "ai-assistant.button.run-proposal": "run",
-  "ai-assistant.text.proposal-sent": "execution requested",
   "ai-assistant.text.history-folded": "this conversation grew long — the earlier {count} messages were left out. a new conversation is better for a different topic.",
   "ai-assistant.text.history-folded-summarized": "this conversation grew long — the earlier {count} messages were folded into a summary. a new conversation is better for a different topic.",
   "ai-assistant.button.attach": "Attach",
   "ai-assistant.tooltip.attach-file": "Attach images or files (drag & drop or paste supported)",
   "ai-assistant.text.drop-files-here": "Drop images or files here",
   "ai-assistant.button.remove-attachment": "Remove attachment",
-  "ai-assistant.session.all": "All History"
+  "ai-assistant.session.all": "All History",
+  "ai-assistant.notice.stopped": "the request stopped partway, so only part of it was done.",
+  "ai-assistant.notice.provider-busy": "the ai service did not answer just now. try again in a moment.",
+  "ai-assistant.notice.provider-error": "something went wrong while handling this. tell an administrator if it keeps happening.",
+  "ai-assistant.notice.too-long": "this ran long and stopped at step {iter}. try asking in smaller pieces.",
+  "ai-assistant.notice.tool-kept-failing": "{tool} failed {count} times in a row, so it stopped. try saying it differently.",
+  "ai-assistant.text.no-match": "no match",
+  "ai-assistant.text.messages-unreadable": "could not read this conversation.",
+  "ai-assistant.text.sessions-unreadable": "could not load the conversation list.",
+  "ai-assistant.text.session-not-created": "could not start a conversation.",
+  "ai-assistant.text.proposal-choices": "follow-up choices",
+  "ai-assistant.text.attached-image-ask": "here is an image — go by it.",
+  "ai-assistant.text.attached-file-ask": "here is a file — take a look.",
+  "ai-assistant.text.other-figure-history": "this conversation belongs to another figure. open the conversation of the model you have open.",
+  "ai-assistant.text.application-vs-model-history": "this conversation is about the application, not about a model. open the one you want.",
+  "ai-assistant.text.other-station-history": "this conversation belongs to another station screen. open the conversation of the screen you are on.",
+  "ai-assistant.text.unknown-mode": "this screen asked for a conversation this server does not have ({kind}). reload the page.",
+  "ai-assistant.session.default-name": "conversation {n}",
+  "ai-assistant.match.id": "ID",
+  "ai-assistant.match.name": "Name",
+  "ai-assistant.match.tag": "Tag",
+  "ai-assistant.match.type": "Type",
+  "ai-assistant.match.class": "Class",
+  "ai-assistant.match.text": "Text",
+  "ai-assistant.match.data": "Data",
+  "ai-assistant.match.property": "Prop",
+  "ai-assistant.match.description": "Desc",
+  "ai-assistant.candidate.template": "phrase",
+  "ai-assistant.candidate.user": "person",
+  "ai-assistant.text.match-count": "{shown} / {all} matches",
+  "ai-assistant.text.match-overflow": "+{count} more — narrow the query",
+  "ai-assistant.verdict.accepted": "done",
+  "ai-assistant.verdict.refused": "refused",
+  "ai-assistant.verdict.unavailable": "could not run",
+  "ai-assistant.verdict.declined": "cancelled",
+  "ai-assistant.text.proposal-waiting": "sending — {seconds}s, no answer yet",
+  "ai-assistant.text.proposal-applied-count": " {applied} of {total}",
+  "ai-assistant.text.say-to-room-tooltip": "say this to the people here — the assistant does not answer",
+  "ai-assistant.text.no-room-yet": "this conversation is not saved yet, so there is nobody else in it to talk to",
+  "ai-assistant.text.will-be-invited": "{names} will join this conversation when you send",
+  "ai-assistant.text.cannot-invite": "{names} will not join — only the people already in this conversation can bring someone in",
+  "ai-assistant.text.answer-needs-permission": "you do not have permission to see this answer. ask an administrator for access.",
+  "ai-assistant.label.conversation": "conversation",
+  "ai-assistant.text.switch-conversation": "switch to {name}"
 }

package/translations/ja.json

@@ -59,12 +59,54 @@
   "ai-assistant.text.ungrounded-mention": "確認できない対象に言及しています — 実データにありません:",
   "ai-assistant.text.toggle-system-note": "クリックで展開",
   "ai-assistant.button.run-proposal": "実行",
-  "ai-assistant.text.proposal-sent": "実行を依頼しました",
   "ai-assistant.text.history-folded": "会話が長くなり、前半の {count} 件は省略されました。別の話題なら新しい会話のほうが適しています。",
   "ai-assistant.text.history-folded-summarized": "会話が長くなり、前半の {count} 件は要約にまとめられました。別の話題なら新しい会話のほうが適しています。",
   "ai-assistant.button.attach": "添付",
   "ai-assistant.tooltip.attach-file": "画像またはファイルを添付（クリップボードの貼り付け・ドラッグ＆ドロップ対応）",
   "ai-assistant.text.drop-files-here": "ここに画像やファイルをドロップしてください",
   "ai-assistant.button.remove-attachment": "添付を削除",
-  "ai-assistant.session.all": "すべての履歴"
+  "ai-assistant.session.all": "すべての履歴",
+  "ai-assistant.notice.stopped": "リクエストが途中で止まり、一部だけ処理しました。",
+  "ai-assistant.notice.provider-busy": "AI サービスが今応答していません。少し待ってからもう一度お試しください。",
+  "ai-assistant.notice.provider-error": "処理中に問題が発生しました。同じことが続く場合は管理者にお知らせください。",
+  "ai-assistant.notice.too-long": "処理が長くなり {iter} 段階で止まりました。分けて依頼してみてください。",
+  "ai-assistant.notice.tool-kept-failing": "{tool} の呼び出しが {count} 回続けて失敗したため止まりました。言い方を変えてみてください。",
+  "ai-assistant.text.no-match": "一致するものがありません",
+  "ai-assistant.text.messages-unreadable": "この会話を読み取れませんでした。",
+  "ai-assistant.text.sessions-unreadable": "会話の一覧を読み込めませんでした。",
+  "ai-assistant.text.session-not-created": "会話を開始できませんでした。",
+  "ai-assistant.text.proposal-choices": "次にできること",
+  "ai-assistant.text.attached-image-ask": "画像を添付しました。これを見てお願いします。",
+  "ai-assistant.text.attached-file-ask": "ファイルを添付しました。確認してください。",
+  "ai-assistant.text.other-figure-history": "この会話は別の Figure のものです。今開いているモデルの会話を開いてください。",
+  "ai-assistant.text.application-vs-model-history": "この会話はモデルではなくアプリケーションについてのものです。目的の会話を開いてください。",
+  "ai-assistant.text.other-station-history": "この会話は別の現場画面のものです。今見ている画面の会話を開いてください。",
+  "ai-assistant.text.unknown-mode": "この画面が求める会話がサーバーにありません（{kind}）。ページを再読み込みしてください。",
+  "ai-assistant.session.default-name": "会話 {n}",
+  "ai-assistant.match.id": "ID",
+  "ai-assistant.match.name": "名前",
+  "ai-assistant.match.tag": "タグ",
+  "ai-assistant.match.type": "種類",
+  "ai-assistant.match.class": "クラス",
+  "ai-assistant.match.text": "テキスト",
+  "ai-assistant.match.data": "値",
+  "ai-assistant.match.property": "属性",
+  "ai-assistant.match.description": "説明",
+  "ai-assistant.candidate.template": "文",
+  "ai-assistant.candidate.user": "人",
+  "ai-assistant.text.match-count": "{shown} / {all} 件",
+  "ai-assistant.text.match-overflow": "他 {count} 件 — 検索語を絞ってください",
+  "ai-assistant.verdict.accepted": "適用しました",
+  "ai-assistant.verdict.refused": "拒否されました",
+  "ai-assistant.verdict.unavailable": "実行できませんでした",
+  "ai-assistant.verdict.declined": "取り消しました",
+  "ai-assistant.text.proposal-waiting": "送信中 — {seconds}秒、まだ返事がありません",
+  "ai-assistant.text.proposal-applied-count": " {total} 件中 {applied} 件",
+  "ai-assistant.text.say-to-room-tooltip": "ここにいる人たちに話します。AI は答えません",
+  "ai-assistant.text.no-room-yet": "まだ保存されていない会話なので、一緒にいる人がいません",
+  "ai-assistant.text.will-be-invited": "送信すると {names} がこの会話に加わります",
+  "ai-assistant.text.cannot-invite": "{names} は加わりません。この会話にいる人だけが他の人を呼べます",
+  "ai-assistant.text.answer-needs-permission": "この回答を見る権限がありません。管理者に申請してください。",
+  "ai-assistant.label.conversation": "会話",
+  "ai-assistant.text.switch-conversation": "{name} の会話に切り替える"
 }