@things-factory/ai-assistant 10.1.88 → 10.1.91

package/server/service/index.ts

@@ -10,6 +10,8 @@ import { entities as ChatSessionParticipantEntities } from './chat-session-parti
 import './chat-session/attachment-tools.js'
 import './chat-session/session-purge.js'
 import './chat-session/attachment-route.js'
+import { EntryProposalResolver } from './data-entry/entry-resolver.js'
+import './workspace/workspace-tools.js'
 
 export * from './types.js'
 export * from './chat-session-resolver.js'
@@ -23,6 +25,11 @@ export * from './assistant-capability-resolver.js'
  * 실린다. 시험은 경로로 가져온다: `…/service/testing/conversation-script.js`.
  */
 export * from './tool-access.js'
+/* Data entry from material - an app registers what it can enter; a mode names it (design/ai/data-entry.md). */
+export * from './data-entry/entry-target.js'
+export { registerEntryTarget, entryCategoryOf } from './data-entry/entry-tools.js'
+/* The AI 작업판 - large results on a page of their own (design/ai/workspace.md). */
+export * from './workspace/workspace-blocks.js'
 /* 무엇이 근거인가 — 도구 결과 밖의 셋(프롬프트 · 대화 · 화면 스냅숏). */
 export * from './grounding-sources.js'
 /* 앵커 순수 로직 — 호스트가 앵커 종류를 참조한다(리졸버는 데코레이터 때문에 무겁다). */
@@ -63,6 +70,8 @@ export const schema = {
     AssistantCapabilityResolver,
     ChatMessageSubscription,
     /* 내가 참여한 모든 세션의 활동 — 창을 닫아 둔 표면이 배지·목록을 갱신할 수 있게. */
-    MySessionActivitySubscription
+    MySessionActivitySubscription,
+    /* 사람이 누른 입력 제안을 쓰는 자리 — 행마다 앱의 코드로, 그 사람의 권한으로. */
+    EntryProposalResolver
   ]
 }

package/server/service/workspace/workspace-blocks.ts

@@ -0,0 +1,127 @@
+/*
+ * The AI 작업판 - what a workspace is made of (operato-application/design/ai/workspace.md §3).
+ *
+ * The model does not write HTML. A workspace is a list of blocks of known kinds; the screen draws each, so
+ * theme, language and accessibility are the framework's. A block that does not fit is not dropped: it is
+ * kept as a fact in its place ("a block that cannot be drawn"), so the person sees that something was meant
+ * to be there. Pure - tested without a server.
+ */
+
+export const WORKSPACE_BLOCK_KINDS = ['heading', 'text', 'metrics', 'table', 'chart', 'steps'] as const
+export type WorkspaceBlockKind = (typeof WORKSPACE_BLOCK_KINDS)[number]
+
+export const MAX_BLOCKS = 40
+export const MAX_TABLE_ROWS = 1000
+export const MAX_SERIES = 8
+const MAX_TEXT = 20_000
+
+export interface WorkspaceBlock {
+  kind: WorkspaceBlockKind | 'unreadable'
+  [key: string]: unknown
+}
+
+export interface Workspace {
+  name: string
+  title: string
+  summary?: string
+  blocks: WorkspaceBlock[]
+}
+
+const text = (value: unknown, max = 500): string | undefined => (typeof value === 'string' && value.trim() ? value.trim().slice(0, max) : undefined)
+const scalar = (value: unknown): string | number | boolean | null =>
+  value === null || value === undefined ? null : typeof value === 'number' || typeof value === 'boolean' ? value : String(value).slice(0, 500)
+
+/** A short key of the workspace - the same name in one conversation is the same workspace, a new version. */
+export function workspaceName(name: unknown, title: string): string {
+  const given = typeof name === 'string' ? name.trim().toLowerCase() : ''
+  if (/^[a-z0-9][a-z0-9-]{0,63}$/.test(given)) return given
+  const slug = (given || title)
+    .toLowerCase()
+    .replace(/[^a-z0-9가-힣]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 64)
+  return slug || 'workspace'
+}
+
+function unreadable(kind: unknown, reason: string): WorkspaceBlock {
+  return { kind: 'unreadable', was: typeof kind === 'string' ? kind.slice(0, 40) : null, reason }
+}
+
+function block(raw: any): WorkspaceBlock {
+  const kind = raw?.kind
+  switch (kind) {
+    case 'heading': {
+      const value = text(raw.text, 200)
+      if (!value) return unreadable(kind, 'no-text')
+      const level = [1, 2, 3].includes(raw.level) ? raw.level : 2
+      return { kind, text: value, level }
+    }
+    case 'text': {
+      const value = text(raw.markdown ?? raw.text, MAX_TEXT)
+      return value ? { kind, markdown: value } : unreadable(kind, 'no-text')
+    }
+    case 'metrics': {
+      const items = (Array.isArray(raw.items) ? raw.items : [])
+        .filter((one: any) => text(one?.label) && one?.value !== undefined && one?.value !== null)
+        .slice(0, 12)
+        .map((one: any) => ({ label: text(one.label, 80), value: scalar(one.value), ...(text(one.unit, 20) ? { unit: text(one.unit, 20) } : {}), ...(text(one.note, 200) ? { note: text(one.note, 200) } : {}) }))
+      return items.length ? { kind, items } : unreadable(kind, 'no-items')
+    }
+    case 'table': {
+      const columns = (Array.isArray(raw.columns) ? raw.columns : [])
+        .filter((one: any) => text(one?.name, 80))
+        .slice(0, 30)
+        .map((one: any) => ({ name: text(one.name, 80)!, ...(text(one.label, 80) ? { label: text(one.label, 80) } : {}), type: ['number', 'date', 'string'].includes(one.type) ? one.type : 'string' }))
+      if (!columns.length) return unreadable(kind, 'no-columns')
+      const given = Array.isArray(raw.rows) ? raw.rows : []
+      /* A row is an object by column name, or an array in column order - models write both. */
+      const rows = given.slice(0, MAX_TABLE_ROWS).map((row: any) =>
+        Object.fromEntries(columns.map((column: any, i: number) => [column.name, scalar(Array.isArray(row) ? row[i] : row?.[column.name])]))
+      )
+      return { kind, columns, rows, ...(text(raw.caption, 300) ? { caption: text(raw.caption, 300) } : {}), ...(given.length > MAX_TABLE_ROWS ? { cut: given.length - MAX_TABLE_ROWS } : {}) }
+    }
+    case 'chart': {
+      const x = (Array.isArray(raw.x) ? raw.x : []).slice(0, 200).map((one: unknown) => String(one ?? '').slice(0, 60))
+      const series = (Array.isArray(raw.series) ? raw.series : [])
+        .filter((one: any) => text(one?.name, 60) && Array.isArray(one?.values))
+        .map((one: any) => ({ name: text(one.name, 60)!, values: x.map((_: unknown, i: number) => (typeof one.values[i] === 'number' && Number.isFinite(one.values[i]) ? one.values[i] : null)) }))
+      if (!x.length || !series.length) return unreadable(kind, 'no-series')
+      /* Never a ninth hue: past eight, the first seven stay and the rest fold into one "other". */
+      const shown =
+        series.length > MAX_SERIES
+          ? [
+              ...series.slice(0, MAX_SERIES - 1),
+              { name: 'other', other: true, values: x.map((_: unknown, i: number) => series.slice(MAX_SERIES - 1).reduce((acc: number, one: any) => acc + (one.values[i] ?? 0), 0)) }
+            ]
+          : series
+      return { kind, chart: raw.chart === 'line' || raw.type === 'line' || raw.shape === 'line' ? 'line' : 'bar', x, series: shown, ...(text(raw.unit, 20) ? { unit: text(raw.unit, 20) } : {}), ...(text(raw.caption, 300) ? { caption: text(raw.caption, 300) } : {}) }
+    }
+    case 'steps': {
+      const items = (Array.isArray(raw.items) ? raw.items : [])
+        .filter((one: any) => text(one?.label, 200))
+        .slice(0, 50)
+        .map((one: any) => ({ label: text(one.label, 200), state: ['done', 'doing', 'todo', 'failed'].includes(one.state) ? one.state : 'todo', ...(text(one.note, 300) ? { note: text(one.note, 300) } : {}) }))
+      return items.length ? { kind, items } : unreadable(kind, 'no-items')
+    }
+    default:
+      return unreadable(kind, 'unknown-kind')
+  }
+}
+
+/** The workspace as the screen reads it. */
+export function normalizeWorkspace(args: any): { workspace?: Workspace; error?: string } {
+  const title = text(args?.title, 200)
+  if (!title) return { error: 'no-title' }
+  const given = Array.isArray(args?.blocks) ? args.blocks : []
+  if (!given.length) return { error: 'no-blocks' }
+  const blocks = given.slice(0, MAX_BLOCKS).map(block)
+  if (given.length > MAX_BLOCKS) blocks.push({ kind: 'unreadable', was: null, reason: 'too-many-blocks', cut: given.length - MAX_BLOCKS })
+  return { workspace: { name: workspaceName(args?.name, title), title, ...(text(args?.summary, 500) ? { summary: text(args.summary, 500) } : {}), blocks } }
+}
+
+/** One line of what is in it - for the card in the conversation and for the model. */
+export function workspaceContents(workspace: Workspace): Record<string, number> {
+  const counts: Record<string, number> = {}
+  for (const one of workspace.blocks) if (['table', 'chart', 'metrics', 'steps'].includes(one.kind)) counts[one.kind] = (counts[one.kind] ?? 0) + 1
+  return counts
+}

package/server/service/workspace/workspace-tools.ts

@@ -0,0 +1,66 @@
+/*
+ * showInWorkspace - the model puts a large result on the AI 작업판 (operato-application/design/ai/workspace.md §5).
+ *
+ * The result rides on the answer as a proposal of kind 'workspace', so the conversation's gates hold for it:
+ * who may read the conversation reads the workspace, and a value behind a door the reader cannot pass hides
+ * it with the answer (ADR-0073). The tool itself reaches no door - what it carries came from the turn's other
+ * tools, whose doors the answer row collects.
+ */
+import { registerToolCategory, type ToolCategory, type ToolSpec } from '@things-factory/ai-client-base'
+
+import { normalizeWorkspace, workspaceContents, WORKSPACE_BLOCK_KINDS } from './workspace-blocks.js'
+
+export const WORKSPACE_CATEGORY = 'assistant-workspace'
+
+export function showInWorkspace(args: any) {
+  const { workspace, error } = normalizeWorkspace(args)
+  if (!workspace) return { rejected: true, error, message: 'a workspace needs a title and at least one block.' }
+  const contents = workspaceContents(workspace)
+  return {
+    proposed: true,
+    kind: 'workspace',
+    icon: 'dashboard',
+    label: workspace.title,
+    workspace,
+    contents,
+    message: `put "${workspace.title}" on the workspace (${workspace.blocks.length} blocks). The person opens it from the card - say in one line what it holds; do not repeat its tables in the answer.`
+  }
+}
+
+const spec = {
+  kind: 'read',
+  name: 'showInWorkspace',
+  doors: [],
+  description:
+    'Put a large result on the AI workspace - a page the person opens from a card, beside the conversation. Blocks: ' +
+    'heading{text,level}, text{markdown}, metrics{items:[{label,value,unit,note}]}, table{columns:[{name,label,type:number|date|string}],rows,caption}, ' +
+    'chart{chart:bar|line, x:[labels], series:[{name,values:[numbers]}], unit, caption}, steps{items:[{label,state:done|doing|todo|failed,note}]}.',
+  schema: {
+    type: 'object',
+    properties: {
+      name: { type: 'string', description: 'A short key, lowercase with dashes ("contracts-by-customer"). The same name again makes a new version of the same workspace.' },
+      title: { type: 'string' },
+      summary: { type: 'string', description: 'One line under the title.' },
+      blocks: {
+        type: 'array',
+        items: { type: 'object', properties: { kind: { type: 'string', enum: [...WORKSPACE_BLOCK_KINDS] } }, required: ['kind'] }
+      }
+    },
+    required: ['name', 'title', 'blocks']
+  },
+  builder: (args: any) => showInWorkspace(args)
+} as ToolSpec
+
+export const workspaceCategory: ToolCategory = {
+  name: WORKSPACE_CATEGORY,
+  description: 'the AI workspace - a page for results too large for the conversation',
+  guidance: [
+    '- When a result is more than a short table (over 20 rows, or two or more tables or charts), or the person asks for a page, call showInWorkspace. Keep the answer short: the point, and that it is on the workspace.',
+    '- Every number in a block comes from a tool result in this conversation - never computed or guessed by you.',
+    '- To change a workspace, call showInWorkspace again with the same name and the whole new content; it becomes a new version.',
+    '- Never say something is on the workspace unless you called showInWorkspace in this turn.'
+  ].join('\n'),
+  specs: [spec]
+}
+
+registerToolCategory(workspaceCategory)

package/server/service/workspace/workspace.test.ts

@@ -0,0 +1,58 @@
+/*
+ * The AI 작업판 (design/ai/workspace.md) - what a block may be, what happens to one that is not, and what the
+ * tool hands back.
+ */
+import { normalizeWorkspace, workspaceName, MAX_SERIES } from './workspace-blocks'
+import { showInWorkspace, workspaceCategory } from './workspace-tools'
+
+describe('the workspace', () => {
+  it('★ is blocks of known kinds - a block that does not fit stays in its place as a fact, never dropped silently', () => {
+    const { workspace } = normalizeWorkspace({
+      name: 'contracts',
+      title: '2026 contracts',
+      blocks: [{ kind: 'heading', text: 'By customer' }, { kind: 'html', html: '<script>x</script>' }, { kind: 'table', rows: [] }]
+    })
+    expect(workspace!.blocks).toEqual([
+      { kind: 'heading', text: 'By customer', level: 2 },
+      { kind: 'unreadable', was: 'html', reason: 'unknown-kind' },
+      { kind: 'unreadable', was: 'table', reason: 'no-columns' }
+    ])
+  })
+
+  it('reads a table row as an object by column or an array in column order, and cuts at the limit saying how many', () => {
+    const rows = [{ customer: 'A', amount: 10 }, ['B', 20], ...Array.from({ length: 1000 }, () => ({ customer: 'x', amount: 1 }))]
+    const table: any = normalizeWorkspace({ title: 't', blocks: [{ kind: 'table', columns: [{ name: 'customer' }, { name: 'amount', type: 'number' }], rows }] }).workspace!.blocks[0]
+    expect(table.rows.slice(0, 2)).toEqual([{ customer: 'A', amount: 10 }, { customer: 'B', amount: 20 }])
+    expect(table.rows).toHaveLength(1000)
+    expect(table.cut).toBe(2)
+  })
+
+  it('★ a chart never gets a ninth colour - past eight series the rest fold into "other"', () => {
+    const series = Array.from({ length: 10 }, (_, i) => ({ name: `s${i}`, values: [1, 2] }))
+    const chart: any = normalizeWorkspace({ title: 't', blocks: [{ kind: 'chart', x: ['Jan', 'Feb'], series }] }).workspace!.blocks[0]
+    expect(chart.series).toHaveLength(MAX_SERIES)
+    expect(chart.series[MAX_SERIES - 1]).toEqual({ name: 'other', other: true, values: [3, 6] })
+    expect(chart.chart).toBe('bar')
+  })
+
+  it('a value that is not a number is a gap in the chart, never a zero', () => {
+    const chart: any = normalizeWorkspace({ title: 't', blocks: [{ kind: 'chart', chart: 'line', x: ['a', 'b', 'c'], series: [{ name: 'n', values: [1, 'x', 3] }] }] }).workspace!.blocks[0]
+    expect(chart.series[0].values).toEqual([1, null, 3])
+  })
+
+  it('the same name is the same workspace - a name that is not a key is made one from it', () => {
+    expect(workspaceName('contracts-by-customer', 'x')).toBe('contracts-by-customer')
+    expect(workspaceName(undefined, '2026 Contracts / 고객사')).toBe('2026-contracts-고객사')
+  })
+
+  it('★ the tool hands back a proposal of kind workspace, so the answer row carries it - and the conversation gates it', () => {
+    const result: any = showInWorkspace({ name: 'c', title: 'Contracts', blocks: [{ kind: 'table', columns: [{ name: 'a' }], rows: [[1]] }, { kind: 'metrics', items: [{ label: 'n', value: 26 }] }] })
+    expect(result).toMatchObject({ proposed: true, kind: 'workspace', label: 'Contracts', contents: { table: 1, metrics: 1 } })
+    expect((workspaceCategory.specs[0] as any).doors).toEqual([])
+  })
+
+  it('no title or no blocks is refused, with what it needs', () => {
+    expect(showInWorkspace({ blocks: [{ kind: 'text', markdown: 'x' }] })).toMatchObject({ rejected: true, error: 'no-title' })
+    expect(showInWorkspace({ title: 'x', blocks: [] })).toMatchObject({ rejected: true, error: 'no-blocks' })
+  })
+})

package/test/entry-proposal.test.ts

@@ -0,0 +1,67 @@
+/*
+ * The data entry card on the screen (design/ai/data-entry.md §5) - what it counts, which card is current,
+ * and what it leaves in the conversation. The chat's wiring is read as text: importing it pulls the shell.
+ */
+import { readFileSync } from 'fs'
+import { join } from 'path'
+
+import { runProposal, setEntryProposalHandler } from '../client/utils/assistant-proposals'
+import {
+  entryOutcomeNote,
+  entryProposalHandler,
+  entryReadyCount,
+  latestEntryKeys,
+  type EntryApplyAnswer
+} from '../client/utils/entry-proposal'
+
+const t = (key: string, options: any = {}) =>
+  String(options.defaultValue ?? key).replace(/\{(\w+)\}/g, (_, name) => String(options[name] ?? ''))
+
+const card = (key: string, target = 'office.expense-line', rows: any[] = []) => ({ key, kind: 'entry', target, rows })
+
+describe('the entry card', () => {
+  it('★ counts only the rows that will go in', () => {
+    const p = card('k', undefined, [
+      { index: 0, values: {}, sources: [], issues: [] },
+      { index: 1, values: {}, sources: [], issues: [{ code: 'required', field: 'amount', blocking: true }] },
+      { index: 2, values: {}, sources: [], issues: [{ code: 'no-source', blocking: false }] }
+    ])
+    expect(entryReadyCount(p)).toBe(2)
+  })
+
+  it('★ the newest card per record is the current one - an older one is replaced', () => {
+    const latest = latestEntryKeys([[card('k1')], [{ key: 'x', tool: 'proposeAction' }], [card('k2'), card('k3', 'office.leave')]])
+    expect(latest.get('office.expense-line')).toBe('k2')
+    expect(latest.get('office.leave')).toBe('k3')
+  })
+
+  it('leaves in the conversation what went in and each row that did not, by its place', () => {
+    const answer: EntryApplyAnswer = {
+      verdict: 'accepted',
+      applied: 2,
+      missed: 1,
+      rows: [{ index: 0, ok: true }, { index: 1, ok: false, error: 'closed period' }, { index: 2, ok: true }]
+    }
+    expect(entryOutcomeNote(answer, t)).toBe('entered 2 rows.\nrow 2: closed period')
+  })
+
+  it('★ every entry card runs the one framework handler, whatever record it enters - no app registers one', async () => {
+    const asked: string[] = []
+    setEntryProposalHandler(
+      entryProposalHandler(async (sessionId, key) => {
+        asked.push(`${sessionId}/${key}`)
+        return { verdict: 'accepted', applied: 1, missed: 0, rows: [{ index: 0, ok: true }] }
+      }, t)
+    )
+    const outcome = await runProposal({ ...card('k9'), tool: 'proposeOfficeExpenseLineEntries' }, { sessionId: 's1', confirm: async () => true, notify: () => {} })
+    expect(asked).toEqual(['s1/k9'])
+    expect(outcome).toMatchObject({ verdict: 'accepted', applied: 1, missed: 0 })
+  })
+
+  it('the chat draws the review and names the button by the rows it enters', () => {
+    const chat = readFileSync(join(__dirname, '..', 'client', 'components', 'assistant-chat.ts'), 'utf8')
+    expect(chat).toContain('<ox-assistant-entry-review .proposal=${p}>')
+    expect(chat).toContain("'ai-assistant.entry.enter'")
+    expect(chat).toContain("'ai-assistant.entry.replaced'")
+  })
+})

package/test/open-doors.test.ts

@@ -142,11 +142,12 @@ describe('what the walk itself has to be true for', () => {
      * 2026-09-24: 27 root fields, 25 declared, 2 open — both streams.
      * 2026-09-25: 28 — attachToConversation (a conversation's files, shared dock §9), declared.
      * 2026-09-28: 29 — requestProposal (a proposal is requested once, ADR-0097 Q-D4), declared.
+     * 2026-09-30: 30 — applyEntryProposal (enter the rows the person pressed, design/ai/data-entry.md), declared.
      */
     const all = fieldsOf('Query').length + fieldsOf('Mutation').length + fieldsOf('Subscription').length
     const open = openFields('Query').length + openFields('Mutation').length + openFields('Subscription').length
 
-    expect(all).toBe(29)
+    expect(all).toBe(30)
     expect(open).toBe(2)
   })
 })

package/test/workspace.test.ts

@@ -0,0 +1,54 @@
+/*
+ * The AI 작업판 on the screen (design/ai/workspace.md) - which versions a reader sees, the card's version, and the
+ * table's sort and CSV. The page and the chat are read as text: importing them pulls the shell.
+ */
+import { readFileSync } from 'fs'
+import { join } from 'path'
+
+import { sortRows, tableCsv, versionOfCard, workspaceAddress, workspaceVersions } from '../client/utils/workspace'
+
+const ws = (name: string, title = name) => ({ key: `k-${title}`, kind: 'workspace', workspace: { name, title, blocks: [] } })
+
+describe('the workspace on the screen', () => {
+  it('★ the same name in one conversation is one workspace; its versions are counted in order', () => {
+    const messages = [
+      { id: 'm1', proposalsJson: [ws('contracts', 'v1')] },
+      { id: 'm2', proposalsJson: [{ key: 'x', tool: 'proposeAction' }, ws('loans', 'l1')] },
+      { id: 'm3', proposalsJson: null },
+      { id: 'm4', proposalsJson: [ws('contracts', 'v2')] }
+    ]
+    expect(workspaceVersions(messages, 'contracts').map(one => `${one.version}:${one.messageId}:${one.workspace.title}`)).toEqual(['1:m1:v1', '2:m4:v2'])
+  })
+
+  it('★ a version behind a door the reader cannot pass is not among them - its row comes back without proposals', () => {
+    const messages = [{ id: 'm1', proposalsJson: [ws('contracts', 'v1')] }, { id: 'm2', proposalsJson: null }]
+    expect(workspaceVersions(messages, 'contracts')).toHaveLength(1)
+  })
+
+  it('a card knows which version it is', () => {
+    expect(versionOfCard([[ws('c', 'a')], [ws('d', 'x')], [ws('c', 'b')]], 'c', 'k-b')).toEqual({ version: 2, of: 2 })
+  })
+
+  it('the address carries the conversation, the name and the version', () => {
+    expect(workspaceAddress('s-1', 'contracts', 2)).toBe('assistant-workspace?session=s-1&name=contracts&version=2')
+  })
+
+  it('sorts numbers as numbers and puts empty cells last, both ways', () => {
+    const rows = [{ v: 10 }, { v: null }, { v: 9 }, { v: 100 }]
+    expect(sortRows(rows, 'v', 'asc').map(row => row.v)).toEqual([9, 10, 100, null])
+    expect(sortRows(rows, 'v', 'desc').map(row => row.v)).toEqual([100, 10, 9, null])
+  })
+
+  it('CSV quotes what needs quoting and starts with a BOM so a spreadsheet reads Korean', () => {
+    expect(tableCsv([{ name: 'a', label: '고객사' }, { name: 'b' }], [{ a: 'A, Inc', b: 'say "hi"' }])).toBe('고객사,b\r\n"A, Inc","say ""hi"""')
+  })
+
+  it('★ the card opens the page and runs nothing; the page reads the conversation through its own door', () => {
+    const chat = readFileSync(join(__dirname, '..', 'client', 'components', 'assistant-chat.ts'), 'utf8')
+    expect(chat).toContain('if (isWorkspaceProposal(p)) return this.renderWorkspaceCard(p, key)')
+    const page = readFileSync(join(__dirname, '..', 'client', 'pages', 'assistant-workspace-page.ts'), 'utf8')
+    expect(page).toContain('chatMessages(sessionId: $sessionId')
+    const config = readFileSync(join(__dirname, '..', 'things-factory.config.js'), 'utf8')
+    expect(config).toContain("page: 'assistant-workspace'")
+  })
+})

package/things-factory.config.js

@@ -1 +1,6 @@
-export default {}
+import route from './dist-client/route.js'
+
+export default {
+  route,
+  routes: [{ tagname: 'assistant-workspace-page', page: 'assistant-workspace' }]
+}

package/translations/en.json

@@ -197,5 +197,60 @@
   "ai-assistant.session.filter-private": "Private",
   "ai-assistant.session.filter-unread": "Unread",
   "ai-assistant.dock.ask-needs-conversation": "the question was not sent.",
-  "ai-assistant.dock.audience-open-band": "Public conversation - everyone in this domain can read and write here."
+  "ai-assistant.dock.audience-open-band": "Public conversation - everyone in this domain can read and write here.",
+  "ai-assistant.entry.rows": "{count} rows",
+  "ai-assistant.entry.ready": "{count} ready",
+  "ai-assistant.entry.blocked": "{count} will not be entered",
+  "ai-assistant.entry.cut": "{count} left out over the limit",
+  "ai-assistant.entry.source": "from",
+  "ai-assistant.entry.missing": "missing",
+  "ai-assistant.entry.more-rows": "{count} more rows are not shown - they are entered too.",
+  "ai-assistant.entry.check-failed": "the application could not check these rows; they are checked again when entered.",
+  "ai-assistant.entry.replaced": "replaced by a newer card",
+  "ai-assistant.entry.enter": "enter {count} rows",
+  "ai-assistant.entry.nothing-to-enter": "nothing to enter",
+  "ai-assistant.entry.entered": "entered {count} rows.",
+  "ai-assistant.entry.entered-none": "no row was entered.",
+  "ai-assistant.entry.row-refused": "row {n}: {reason}",
+  "ai-assistant.entry.more-refused": "{count} more rows were not entered.",
+  "ai-assistant.entry.issue.required": "no value",
+  "ai-assistant.entry.issue.not-a-number": "not a number",
+  "ai-assistant.entry.issue.not-an-integer": "not a whole number",
+  "ai-assistant.entry.issue.not-a-date": "not a date",
+  "ai-assistant.entry.issue.not-a-boolean": "not yes or no",
+  "ai-assistant.entry.issue.not-in-list": "not one of {values}",
+  "ai-assistant.entry.issue.unknown-field": "not a field of this record - left out",
+  "ai-assistant.entry.issue.no-source": "no source given",
+  "ai-assistant.entry.verified": "{count} found in their file",
+  "ai-assistant.entry.unmatched": "{count} with a value their file does not have",
+  "ai-assistant.entry.evidence": "found on line {line} of the file",
+  "ai-assistant.entry.total": "{field} total {sum}",
+  "ai-assistant.entry.total-ready": "entered {sum}",
+  "ai-assistant.entry.total-declared": "the material says {sum}",
+  "ai-assistant.entry.total-not-found": "not found in the file",
+  "ai-assistant.entry.total-differs": "differs by {sum}",
+  "ai-assistant.entry.total-matches": "matches",
+  "ai-assistant.entry.issue.not-in-source": "the file does not have this value",
+  "ai-assistant.entry.issue.source-scattered": "the values are not on one line of the file",
+  "ai-assistant.entry.issue.source-not-checked": "a photo cannot be checked here",
+  "ai-assistant.workspace.title": "AI workspace",
+  "ai-assistant.workspace.unreadable": "a block that cannot be drawn ({reason})",
+  "ai-assistant.workspace.rows": "{count} rows",
+  "ai-assistant.workspace.csv": "CSV",
+  "ai-assistant.workspace.cut": "{count} more rows were left out over the limit.",
+  "ai-assistant.workspace.other": "other",
+  "ai-assistant.workspace.as-chart": "chart",
+  "ai-assistant.workspace.as-table": "table",
+  "ai-assistant.workspace.loading": "loading the workspace…",
+  "ai-assistant.workspace.unreadable-page": "could not read this workspace: {reason}",
+  "ai-assistant.workspace.not-found": "there is no workspace here that you can see.",
+  "ai-assistant.workspace.newer": "a newer version ({version}) is ready.",
+  "ai-assistant.workspace.show-newer": "show it",
+  "ai-assistant.workspace.versions": "versions",
+  "ai-assistant.workspace.version": "version {version} of {of}",
+  "ai-assistant.workspace.open": "open in workspace",
+  "ai-assistant.workspace.contains-table": "{count} tables",
+  "ai-assistant.workspace.contains-chart": "{count} charts",
+  "ai-assistant.workspace.contains-metrics": "{count} figures",
+  "ai-assistant.workspace.contains-steps": "{count} progress"
 }

package/translations/ja.json

@@ -197,5 +197,60 @@
   "ai-assistant.session.filter-private": "非公開",
   "ai-assistant.session.filter-unread": "未読",
   "ai-assistant.dock.ask-needs-conversation": "質問は送信されませんでした。",
-  "ai-assistant.dock.audience-open-band": "公開会話 — この事業所の誰でも読み書きできます。"
+  "ai-assistant.dock.audience-open-band": "公開会話 — この事業所の誰でも読み書きできます。",
+  "ai-assistant.entry.rows": "{count}行",
+  "ai-assistant.entry.ready": "入力可能 {count}",
+  "ai-assistant.entry.blocked": "{count}行は入力しません",
+  "ai-assistant.entry.cut": "上限を超えた{count}行は除外されました",
+  "ai-assistant.entry.source": "出典",
+  "ai-assistant.entry.missing": "なし",
+  "ai-assistant.entry.more-rows": "残り{count}行は表示されませんが、一緒に入力します。",
+  "ai-assistant.entry.check-failed": "アプリケーションがこれらの行を検査できませんでした。入力時に再検査します。",
+  "ai-assistant.entry.replaced": "新しいカードに置き換え",
+  "ai-assistant.entry.enter": "{count}行を入力",
+  "ai-assistant.entry.nothing-to-enter": "入力できる行なし",
+  "ai-assistant.entry.entered": "{count}行を入力しました。",
+  "ai-assistant.entry.entered-none": "入力された行はありません。",
+  "ai-assistant.entry.row-refused": "{n}行目: {reason}",
+  "ai-assistant.entry.more-refused": "さらに{count}行が入力されませんでした。",
+  "ai-assistant.entry.issue.required": "値がありません",
+  "ai-assistant.entry.issue.not-a-number": "数値ではありません",
+  "ai-assistant.entry.issue.not-an-integer": "整数ではありません",
+  "ai-assistant.entry.issue.not-a-date": "日付ではありません",
+  "ai-assistant.entry.issue.not-a-boolean": "はい/いいえではありません",
+  "ai-assistant.entry.issue.not-in-list": "許可された値ではありません ({values})",
+  "ai-assistant.entry.issue.unknown-field": "この記録にない項目のため除外しました",
+  "ai-assistant.entry.issue.no-source": "出典がありません",
+  "ai-assistant.entry.verified": "{count}行を資料と照合済み",
+  "ai-assistant.entry.unmatched": "{count}行に資料にない値",
+  "ai-assistant.entry.evidence": "資料の{line}行目で確認",
+  "ai-assistant.entry.total": "{field} 合計 {sum}",
+  "ai-assistant.entry.total-ready": "入力分 {sum}",
+  "ai-assistant.entry.total-declared": "資料の合計 {sum}",
+  "ai-assistant.entry.total-not-found": "資料で見つかりません",
+  "ai-assistant.entry.total-differs": "差 {sum}",
+  "ai-assistant.entry.total-matches": "一致",
+  "ai-assistant.entry.issue.not-in-source": "資料にない値です",
+  "ai-assistant.entry.issue.source-scattered": "値が資料の同じ行にありません",
+  "ai-assistant.entry.issue.source-not-checked": "写真の資料は照合できませんでした",
+  "ai-assistant.workspace.title": "AI作業ボード",
+  "ai-assistant.workspace.unreadable": "描画できないブロックです ({reason})",
+  "ai-assistant.workspace.rows": "{count}行",
+  "ai-assistant.workspace.csv": "CSV",
+  "ai-assistant.workspace.cut": "上限を超えた{count}行は除外されました。",
+  "ai-assistant.workspace.other": "その他",
+  "ai-assistant.workspace.as-chart": "チャート",
+  "ai-assistant.workspace.as-table": "表で見る",
+  "ai-assistant.workspace.loading": "作業ボードを読み込み中…",
+  "ai-assistant.workspace.unreadable-page": "作業ボードを読み込めませんでした: {reason}",
+  "ai-assistant.workspace.not-found": "表示できる作業ボードがありません。",
+  "ai-assistant.workspace.newer": "新しい版（{version}）があります。",
+  "ai-assistant.workspace.show-newer": "表示",
+  "ai-assistant.workspace.versions": "版",
+  "ai-assistant.workspace.version": "版 {version} / {of}",
+  "ai-assistant.workspace.open": "作業ボードで見る",
+  "ai-assistant.workspace.contains-table": "表 {count}",
+  "ai-assistant.workspace.contains-chart": "チャート {count}",
+  "ai-assistant.workspace.contains-metrics": "指標 {count}",
+  "ai-assistant.workspace.contains-steps": "経過 {count}"
 }

package/translations/ko.json

@@ -197,5 +197,60 @@
   "ai-assistant.session.filter-private": "비공개",
   "ai-assistant.session.filter-unread": "안 읽음",
   "ai-assistant.dock.ask-needs-conversation": "질문을 보내지 않았습니다.",
-  "ai-assistant.dock.audience-open-band": "공개 대화 — 이 사업장의 누구나 읽고 쓸 수 있습니다."
+  "ai-assistant.dock.audience-open-band": "공개 대화 — 이 사업장의 누구나 읽고 쓸 수 있습니다.",
+  "ai-assistant.entry.rows": "{count}행",
+  "ai-assistant.entry.ready": "입력 가능 {count}",
+  "ai-assistant.entry.blocked": "{count}행은 입력하지 않습니다",
+  "ai-assistant.entry.cut": "한도를 넘어 {count}행이 빠졌습니다",
+  "ai-assistant.entry.source": "출처",
+  "ai-assistant.entry.missing": "없음",
+  "ai-assistant.entry.more-rows": "나머지 {count}행은 표에 보이지 않지만 함께 입력합니다.",
+  "ai-assistant.entry.check-failed": "애플리케이션이 이 행들을 검사하지 못했습니다. 입력할 때 다시 검사합니다.",
+  "ai-assistant.entry.replaced": "새 카드로 바뀜",
+  "ai-assistant.entry.enter": "{count}행 입력",
+  "ai-assistant.entry.nothing-to-enter": "입력할 행 없음",
+  "ai-assistant.entry.entered": "{count}행을 입력했습니다.",
+  "ai-assistant.entry.entered-none": "입력한 행이 없습니다.",
+  "ai-assistant.entry.row-refused": "{n}행: {reason}",
+  "ai-assistant.entry.more-refused": "{count}행이 더 입력되지 않았습니다.",
+  "ai-assistant.entry.issue.required": "값이 없습니다",
+  "ai-assistant.entry.issue.not-a-number": "숫자가 아닙니다",
+  "ai-assistant.entry.issue.not-an-integer": "정수가 아닙니다",
+  "ai-assistant.entry.issue.not-a-date": "날짜가 아닙니다",
+  "ai-assistant.entry.issue.not-a-boolean": "예/아니오가 아닙니다",
+  "ai-assistant.entry.issue.not-in-list": "허용된 값이 아닙니다 ({values})",
+  "ai-assistant.entry.issue.unknown-field": "이 기록에 없는 칸이라 뺐습니다",
+  "ai-assistant.entry.issue.no-source": "출처가 없습니다",
+  "ai-assistant.entry.verified": "{count}행 자료와 대조됨",
+  "ai-assistant.entry.unmatched": "{count}행에 자료에 없는 값",
+  "ai-assistant.entry.evidence": "자료 {line}번째 줄에서 확인",
+  "ai-assistant.entry.total": "{field} 합계 {sum}",
+  "ai-assistant.entry.total-ready": "입력분 {sum}",
+  "ai-assistant.entry.total-declared": "자료의 합계 {sum}",
+  "ai-assistant.entry.total-not-found": "자료에서 찾지 못함",
+  "ai-assistant.entry.total-differs": "차이 {sum}",
+  "ai-assistant.entry.total-matches": "일치",
+  "ai-assistant.entry.issue.not-in-source": "자료에 없는 값입니다",
+  "ai-assistant.entry.issue.source-scattered": "값이 자료의 한 줄에 함께 있지 않습니다",
+  "ai-assistant.entry.issue.source-not-checked": "사진 자료는 대조하지 못했습니다",
+  "ai-assistant.workspace.title": "AI 작업판",
+  "ai-assistant.workspace.unreadable": "그릴 수 없는 블록입니다 ({reason})",
+  "ai-assistant.workspace.rows": "{count}행",
+  "ai-assistant.workspace.csv": "CSV",
+  "ai-assistant.workspace.cut": "한도를 넘은 {count}행은 빠졌습니다.",
+  "ai-assistant.workspace.other": "기타",
+  "ai-assistant.workspace.as-chart": "차트",
+  "ai-assistant.workspace.as-table": "표로 보기",
+  "ai-assistant.workspace.loading": "작업판을 불러오는 중…",
+  "ai-assistant.workspace.unreadable-page": "작업판을 읽지 못했습니다: {reason}",
+  "ai-assistant.workspace.not-found": "볼 수 있는 작업판이 없습니다.",
+  "ai-assistant.workspace.newer": "새 판({version})이 있습니다.",
+  "ai-assistant.workspace.show-newer": "보기",
+  "ai-assistant.workspace.versions": "판",
+  "ai-assistant.workspace.version": "판 {version} / {of}",
+  "ai-assistant.workspace.open": "작업판에서 보기",
+  "ai-assistant.workspace.contains-table": "표 {count}",
+  "ai-assistant.workspace.contains-chart": "차트 {count}",
+  "ai-assistant.workspace.contains-metrics": "수치 {count}",
+  "ai-assistant.workspace.contains-steps": "경과 {count}"
 }