@things-factory/ai-assistant 10.1.90 → 10.1.91

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/ai-assistant",
-  "version": "10.1.90",
+  "version": "10.1.91",
   "main": "dist-server/index.js",
   "things-factory": true,
   "author": "heartyoh",
@@ -51,5 +51,5 @@
     "copyfiles": "^2.4.1",
     "rimraf": "^5.0.0"
   },
-  "gitHead": "cc35c48a40020554ceed0b1801dc7955fe027e79"
+  "gitHead": "e9a052f7faaeb5884db1ff8b862b8f05567a31f9"
 }

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

@@ -34,7 +34,8 @@ it('★ the settings come from the registered mode', () => {
 
   expect(settings).toEqual({
     systemPrompt: 'you answer about one space',
-    toolCategories: ['twin-ops'],
+    /* Every conversation may put a large result on the AI 작업판 (design/ai/workspace.md). */
+    toolCategories: ['twin-ops', 'assistant-workspace'],
     requireToolOnFirstTurn: true,
     model: 'claude-sonnet-5',
     temperature: 0.2,

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

@@ -44,15 +44,17 @@ export interface ModeSettings {
 }
 
 /**
- * The categories a mode opens: its own, the attachment reader when it takes files (design/ai/shared-dock.md
- * §9-4), and one propose tool per record it may enter (design/ai/data-entry.md).
+ * The categories a mode opens: its own, the AI 작업판 (design/ai/workspace.md), the attachment reader when it
+ * takes files (design/ai/shared-dock.md §9-4), and one propose tool per record it may enter (design/ai/data-entry.md).
  */
 export function modeToolCategories(mode: { toolCategories?: string[]; attachments?: { kinds?: string[] }; entryTargets?: string[] }): string[] | undefined {
   const extra = [
+    /* Every conversation may put a large result on the AI 작업판 (design/ai/workspace.md). */
+    'assistant-workspace',
     ...(mode.attachments?.kinds?.length ? ['chat-attachments'] : []),
     ...(mode.entryTargets ?? []).map(key => `data-entry:${key}`)
   ]
-  return extra.length ? [...(mode.toolCategories ?? []), ...extra] : mode.toolCategories
+  return [...new Set([...(mode.toolCategories ?? []), ...extra])]
 }
 
 /** The conversation's settings, from the server's declaration. */

package/server/service/data-entry/data-entry.test.ts

@@ -66,8 +66,8 @@ describe('declaring a target', () => {
   })
 
   it('a mode opens a target by naming it', () => {
-    expect(modeToolCategories({ toolCategories: ['office-ops'], entryTargets: ['office.expense-line'] })).toEqual(['office-ops', 'data-entry:office.expense-line'])
-    expect(modeToolCategories({ toolCategories: ['office-ops'] })).toEqual(['office-ops'])
+    expect(modeToolCategories({ toolCategories: ['office-ops'], entryTargets: ['office.expense-line'] })).toEqual(['office-ops', 'assistant-workspace', 'data-entry:office.expense-line'])
+    expect(modeToolCategories({ toolCategories: ['office-ops'] })).toEqual(['office-ops', 'assistant-workspace'])
   })
 })
 

package/server/service/index.ts

@@ -11,6 +11,7 @@ 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'
@@ -27,6 +28,8 @@ 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'
 /* 앵커 순수 로직 — 호스트가 앵커 종류를 참조한다(리졸버는 데코레이터 때문에 무겁다). */

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/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

@@ -232,5 +232,25 @@
   "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.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

@@ -232,5 +232,25 @@
   "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.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

@@ -232,5 +232,25 @@
   "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.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/ms.json

@@ -232,5 +232,25 @@
   "ai-assistant.entry.total-matches": "sepadan",
   "ai-assistant.entry.issue.not-in-source": "fail tiada nilai ini",
   "ai-assistant.entry.issue.source-scattered": "nilai tidak berada pada satu baris fail",
-  "ai-assistant.entry.issue.source-not-checked": "foto tidak dapat disemak di sini"
+  "ai-assistant.entry.issue.source-not-checked": "foto tidak dapat disemak di sini",
+  "ai-assistant.workspace.title": "ruang kerja AI",
+  "ai-assistant.workspace.unreadable": "blok yang tidak dapat dilukis ({reason})",
+  "ai-assistant.workspace.rows": "{count} baris",
+  "ai-assistant.workspace.csv": "CSV",
+  "ai-assistant.workspace.cut": "{count} baris lagi ditinggalkan kerana melebihi had.",
+  "ai-assistant.workspace.other": "lain-lain",
+  "ai-assistant.workspace.as-chart": "carta",
+  "ai-assistant.workspace.as-table": "jadual",
+  "ai-assistant.workspace.loading": "memuatkan ruang kerja…",
+  "ai-assistant.workspace.unreadable-page": "tidak dapat membaca ruang kerja ini: {reason}",
+  "ai-assistant.workspace.not-found": "tiada ruang kerja yang boleh anda lihat di sini.",
+  "ai-assistant.workspace.newer": "versi lebih baharu ({version}) tersedia.",
+  "ai-assistant.workspace.show-newer": "tunjukkan",
+  "ai-assistant.workspace.versions": "versi",
+  "ai-assistant.workspace.version": "versi {version} daripada {of}",
+  "ai-assistant.workspace.open": "buka dalam ruang kerja",
+  "ai-assistant.workspace.contains-table": "{count} jadual",
+  "ai-assistant.workspace.contains-chart": "{count} carta",
+  "ai-assistant.workspace.contains-metrics": "{count} angka",
+  "ai-assistant.workspace.contains-steps": "{count} kemajuan"
 }

package/translations/zh.json

@@ -232,5 +232,25 @@
   "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.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}"
 }