@things-factory/ai-assistant 10.1.91 → 10.1.98

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

@@ -0,0 +1,209 @@
+/*
+ * Changing records that exist - the 수정안 (operato-application/design/ai/data-entry.md §5-1).
+ *
+ * The most expensive mistake is changing the wrong record, so which record is meant is settled here, by the
+ * server, never by the model's memory. A record is picked by the screen (the one being looked at, the rows
+ * selected) or by an id the find tool handed back; whichever way, it is read again through the application's
+ * read query as the person, and a record they cannot see is not found. The card shows what is there now and
+ * what it becomes; pressing reads it once more, and a field that moved in between keeps its row out.
+ *
+ * Pure but for the GraphQL runner, which comes in as an argument - the rules are tested without a server.
+ */
+import {
+  changeToolName,
+  findToolName,
+  readFieldValue,
+  sameFieldValue,
+  type EntryField,
+  type EntryIssue,
+  type EntryRecord,
+  type EntryTarget
+} from './entry-target.js'
+
+/** Runs one of the application's queries or mutations as the person. */
+export type GraphqlRunner = (document: string, variables: Record<string, unknown>) => Promise<{ data?: any; errors?: readonly { message: string }[] }>
+
+/** How the record of a change was picked - said on the card, so the person sees the ground of it. */
+export type ChangeVia = 'current' | 'selected' | 'id'
+
+export interface ChangeRow {
+  index: number
+  id: string
+  via: ChangeVia
+  label?: string
+  /** What the record holds now, for the fields that change - read by the server. */
+  before: Record<string, unknown>
+  values: Record<string, unknown>
+  issues: EntryIssue[]
+}
+
+export const MAX_CHANGES = 100
+
+const blockedChange = (row: { issues: EntryIssue[] }) => row.issues.some(issue => issue.blocking)
+
+/** The fields a target lets change. */
+export function changeableFields(target: EntryTarget): EntryField[] {
+  const names = target.update?.fields
+  return names ? target.fields.filter(field => names.includes(field.name)) : target.fields
+}
+
+/**
+ * The records the changes name. `current` is the record on screen, `selected` every row selected there -
+ * both from the surface's host context, which is **not trusted**: an id from it is only a candidate, read
+ * through the application before anything is shown. Any other ref is an id, from the find tool.
+ */
+export function resolveChangeRefs(
+  targetKey: string,
+  changes: unknown,
+  host: Record<string, any> | undefined
+): { picked: { id: string; via: ChangeVia; values: Record<string, unknown> }[]; unresolved: string[] } {
+  const picked: { id: string; via: ChangeVia; values: Record<string, unknown> }[] = []
+  const unresolved: string[] = []
+  const mine = (one: any) => !one?.target || one.target === targetKey
+  for (const change of Array.isArray(changes) ? changes : []) {
+    const values = change?.values && typeof change.values === 'object' ? change.values : {}
+    const ref = typeof change?.ref === 'string' ? change.ref.trim() : ''
+    if (ref === 'current') {
+      const id = mine(host?.record) ? host?.record?.id : undefined
+      if (typeof id === 'string' && id) picked.push({ id, via: 'current', values })
+      else unresolved.push('current')
+    } else if (ref === 'selected') {
+      const ids = mine(host?.selection) && Array.isArray(host?.selection?.ids) ? host!.selection.ids.filter((id: unknown) => typeof id === 'string' && id) : []
+      if (ids.length) for (const id of ids) picked.push({ id, via: 'selected', values })
+      else unresolved.push('selected')
+    } else if (ref) {
+      picked.push({ id: ref, via: 'id', values })
+    } else {
+      unresolved.push('no-ref')
+    }
+  }
+  return { picked: picked.slice(0, MAX_CHANGES), unresolved }
+}
+
+/** Reads the records by id through the application's read query, as the person. */
+export async function readRecords(target: EntryTarget, ids: string[], run: GraphqlRunner): Promise<Map<string, EntryRecord>> {
+  const update = target.update!
+  const answer = await run(update.read.query, update.read.variables([...new Set(ids)]))
+  if (answer.errors?.length) throw new Error(answer.errors.map(one => one.message).join('; '))
+  return new Map((update.read.recordsOf(answer.data) ?? []).filter(record => record && typeof record.id === 'string').map(record => [record.id, record]))
+}
+
+/** The change rows against what the records hold now. */
+export function changeRows(target: EntryTarget, picked: { id: string; via: ChangeVia; values: Record<string, unknown> }[], records: Map<string, EntryRecord>): ChangeRow[] {
+  const fields = new Map(changeableFields(target).map(field => [field.name, field]))
+  return picked.map((one, index): ChangeRow => {
+    const record = records.get(one.id)
+    const issues: EntryIssue[] = []
+    const values: Record<string, unknown> = {}
+    const before: Record<string, unknown> = {}
+    for (const [name, value] of Object.entries(one.values)) {
+      const field = fields.get(name)
+      if (!field) {
+        issues.push({ field: name, code: 'not-changeable', blocking: false })
+        continue
+      }
+      const { read, code } = value === null || value === '' ? { read: null, code: undefined } : readFieldValue(field, value)
+      if (read === undefined) {
+        values[name] = value
+        issues.push({ field: name, code: code!, params: code === 'not-in-list' ? { values: field.values } : undefined, blocking: true })
+      } else {
+        if (read === null && field.required) issues.push({ field: name, code: 'required', blocking: true })
+        values[name] = read
+      }
+      if (record) before[name] = record[name] ?? null
+    }
+    if (!record) issues.push({ code: 'record-not-found', blocking: true })
+    else if (Object.keys(values).length && Object.keys(values).every(name => sameFieldValue(fields.get(name)!, before[name], values[name])))
+      issues.push({ code: 'no-change', blocking: true })
+    if (!Object.keys(values).length && !issues.some(issue => issue.blocking)) issues.push({ code: 'nothing-to-change', blocking: true })
+    return { index, id: one.id, via: one.via, ...(record && target.update?.labelOf ? { label: target.update.labelOf(record) } : {}), before, values, issues }
+  })
+}
+
+/** What the card needs besides the rows - the fields that change, in the target's order. */
+function changedColumns(target: EntryTarget, rows: ChangeRow[]) {
+  const used = new Set(rows.flatMap(row => Object.keys(row.values)))
+  return changeableFields(target)
+    .filter(field => used.has(field.name))
+    .map(field => ({ name: field.name, type: field.type, ...(field.labelKey ? { labelKey: field.labelKey } : {}) }))
+}
+
+export async function proposeChanges(target: EntryTarget, args: any, context: any, run: GraphqlRunner) {
+  const { picked, unresolved } = resolveChangeRefs(target.key, args?.changes, context?.host)
+  if (!picked.length) {
+    return {
+      rejected: true,
+      error: unresolved.length ? `unresolved-${unresolved[0]}` : 'no-changes',
+      message:
+        unresolved[0] === 'current' || unresolved[0] === 'selected'
+          ? `the screen names no ${unresolved[0] === 'current' ? 'record' : 'selected rows'} of this kind. Ask the person which record, or call ${findToolName(target.key)}.`
+          : `name each record: ref "current", "selected", or an id from ${findToolName(target.key)}. Never guess an id.`
+    }
+  }
+  let records: Map<string, EntryRecord>
+  try {
+    records = await readRecords(target, picked.map(one => one.id), run)
+  } catch (error: any) {
+    return { rejected: true, error: 'read-failed', message: `could not read the records: ${error?.message ?? error}` }
+  }
+  const rows = changeRows(target, picked, records)
+  const blocked = rows.filter(blockedChange).length
+  return {
+    proposed: true,
+    kind: 'entry',
+    op: 'update',
+    target: target.key,
+    labelKey: target.labelKey,
+    label: `${rows.length} ${target.key} changes`,
+    icon: 'edit_note',
+    columns: changedColumns(target, rows),
+    rows,
+    counts: { rows: rows.length, ready: rows.length - blocked, blocked, cut: 0 },
+    ...(typeof args?.note === 'string' && args.note.trim() ? { reason: args.note.trim().slice(0, 300) } : {}),
+    message:
+      `proposed ${rows.length} changes (${rows.length - blocked} ready, ${blocked} blocked). Nothing changes until the person presses the card. ` +
+      'Tell them which records are not found or would not change.'
+  }
+}
+
+export const MAX_CANDIDATES = 20
+
+/** Candidates for what the person described - the model lists them and asks when there is more than one. */
+export async function findRecords(target: EntryTarget, args: any, run: GraphqlRunner) {
+  const find = target.update?.find
+  if (!find) return { rejected: true, error: 'no-find', message: 'this record cannot be searched.' }
+  const criteria: Record<string, unknown> = {}
+  for (const field of find.criteria) {
+    const value = args?.[field.name]
+    if (value === undefined || value === null || value === '') continue
+    const { read } = readFieldValue(field, value)
+    if (read !== undefined) criteria[field.name] = read
+  }
+  const answer = await run(find.query, find.variables(criteria))
+  if (answer.errors?.length) return { rejected: true, error: 'find-failed', message: answer.errors.map(one => one.message).join('; ') }
+  const found = (find.recordsOf(answer.data) ?? []).filter(record => record && typeof record.id === 'string')
+  return {
+    total: found.length,
+    candidates: found.slice(0, MAX_CANDIDATES).map(record => ({ id: record.id, ...(target.update?.labelOf ? { label: target.update.labelOf(record) } : {}), record })),
+    message:
+      found.length === 1
+        ? `one record matches; pass its id to ${changeToolName(target.key)}.`
+        : found.length
+          ? `${found.length} records match${found.length > MAX_CANDIDATES ? ` (first ${MAX_CANDIDATES} shown)` : ''}. List them to the person and ask which - never pick one yourself.`
+          : 'no record matches. Tell the person and ask for more to go on.'
+  }
+}
+
+/**
+ * The rows of a pressed 수정안, against what the records hold now. A row whose field moved since the card was
+ * made is kept out as `changed-since` - it is not overwritten unseen.
+ */
+export function stillAsProposed(target: EntryTarget, rows: ChangeRow[], now: Map<string, EntryRecord>): (ChangeRow & { now?: EntryRecord })[] {
+  const fields = new Map(target.fields.map(field => [field.name, field]))
+  return rows.map(row => {
+    const record = now.get(row.id)
+    if (!record) return { ...row, issues: [...row.issues, { code: 'record-not-found', blocking: true }] }
+    const moved = Object.keys(row.values).find(name => fields.get(name) && !sameFieldValue(fields.get(name)!, record[name] ?? null, row.before[name]))
+    return moved ? { ...row, now: record, issues: [...row.issues, { field: moved, code: 'changed-since', blocking: true }] } : { ...row, now: record }
+  })
+}

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

@@ -75,8 +75,15 @@ function block(raw: any): WorkspaceBlock {
       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. */
+      /* A number column reads "12,400" as 12400 - cells come as text from a model told one type per field. */
+      const cell = (column: any, value: unknown) => {
+        const read = scalar(value)
+        if (column.type !== 'number' || typeof read !== 'string') return read
+        const number = Number(read.replace(/[,\s₩$€]/g, ''))
+        return read.trim() && Number.isFinite(number) ? number : read
+      }
       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])]))
+        Object.fromEntries(columns.map((column: any, i: number) => [column.name, cell(column, 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 } : {}) }
     }

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

@@ -41,9 +41,51 @@ const spec = {
       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.' },
+      /*
+       * Every field of every block is declared, each with one type: Gemini's function schema (an OpenAPI 3.0
+       * subset) refuses a list of types and may leave out a field it was not told of (2026-10-01).
+       */
       blocks: {
         type: 'array',
-        items: { type: 'object', properties: { kind: { type: 'string', enum: [...WORKSPACE_BLOCK_KINDS] } }, required: ['kind'] }
+        items: {
+          type: 'object',
+          properties: {
+            kind: { type: 'string', enum: [...WORKSPACE_BLOCK_KINDS] },
+            text: { type: 'string', description: 'heading' },
+            level: { type: 'integer', description: 'heading: 1-3' },
+            markdown: { type: 'string', description: 'text' },
+            caption: { type: 'string', description: 'table, chart' },
+            unit: { type: 'string', description: 'chart' },
+            chart: { type: 'string', enum: ['bar', 'line'], description: 'chart' },
+            items: {
+              type: 'array',
+              description: 'metrics: {label,value,unit,note}; steps: {label,state,note}',
+              items: {
+                type: 'object',
+                properties: {
+                  label: { type: 'string' },
+                  value: { type: 'string' },
+                  unit: { type: 'string' },
+                  note: { type: 'string' },
+                  state: { type: 'string', enum: ['done', 'doing', 'todo', 'failed'] }
+                }
+              }
+            },
+            columns: {
+              type: 'array',
+              description: 'table',
+              items: { type: 'object', properties: { name: { type: 'string' }, label: { type: 'string' }, type: { type: 'string', enum: ['number', 'date', 'string'] } } }
+            },
+            rows: { type: 'array', description: 'table: each row is its cells in column order', items: { type: 'array', items: { type: 'string' } } },
+            x: { type: 'array', description: 'chart: the labels along the bottom', items: { type: 'string' } },
+            series: {
+              type: 'array',
+              description: 'chart',
+              items: { type: 'object', properties: { name: { type: 'string' }, values: { type: 'array', items: { type: 'number' } } } }
+            }
+          },
+          required: ['kind']
+        }
       }
     },
     required: ['name', 'title', 'blocks']

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

@@ -55,4 +55,20 @@ describe('the workspace', () => {
     expect(showInWorkspace({ blocks: [{ kind: 'text', markdown: 'x' }] })).toMatchObject({ rejected: true, error: 'no-title' })
     expect(showInWorkspace({ title: 'x', blocks: [] })).toMatchObject({ rejected: true, error: 'no-blocks' })
   })
+
+  it('a number column reads the text a model writes - "12,400" is 12400, a word stays a word', () => {
+    const table: any = normalizeWorkspace({ title: 't', blocks: [{ kind: 'table', columns: [{ name: 'a', type: 'number' }], rows: [['12,400'], ['n/a']] }] }).workspace!.blocks[0]
+    expect(table.rows).toEqual([{ a: 12400 }, { a: 'n/a' }])
+  })
+
+  it('★ every field of the tool has one type, and every object says its fields - what Gemini accepts', () => {
+    const walk = (schema: any, path: string, out: string[]) => {
+      if (!schema || typeof schema !== 'object') return out
+      if (Array.isArray(schema.type)) out.push(`${path}: a list of types`)
+      if (schema.type === 'object' && !Object.keys(schema.properties ?? {}).length) out.push(`${path}: an object with no fields`)
+      for (const [key, value] of Object.entries(schema)) if (value && typeof value === 'object') walk(value, `${path}/${key}`, out)
+      return out
+    }
+    expect(walk((workspaceCategory.specs[0] as any).schema, '', [])).toEqual([])
+  })
 })

package/test/entry-proposal.test.ts

@@ -7,6 +7,7 @@ import { join } from 'path'
 
 import { runProposal, setEntryProposalHandler } from '../client/utils/assistant-proposals'
 import {
+  entryGroupOf,
   entryOutcomeNote,
   entryProposalHandler,
   entryReadyCount,
@@ -31,8 +32,8 @@ describe('the entry card', () => {
 
   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')
+    expect(latest.get('office.expense-line:create')).toBe('k2')
+    expect(latest.get('office.leave:create')).toBe('k3')
   })
 
   it('leaves in the conversation what went in and each row that did not, by its place', () => {
@@ -64,4 +65,16 @@ describe('the entry card', () => {
     expect(chat).toContain("'ai-assistant.entry.enter'")
     expect(chat).toContain("'ai-assistant.entry.replaced'")
   })
+
+  it('★ a 입력안 and a 수정안 of one record are counted apart - a newer 수정안 replaces only the older 수정안', () => {
+    const latest = latestEntryKeys([[card('e1')], [{ ...card('u1'), op: 'update' }], [card('e2')]])
+    expect(latest.get(entryGroupOf(card('x')))).toBe('e2')
+    expect(latest.get(entryGroupOf({ ...card('x'), op: 'update' }))).toBe('u1')
+  })
+
+  it('a 수정안 says in the conversation what was changed', () => {
+    expect(entryOutcomeNote({ verdict: 'accepted', applied: 1, missed: 1, op: 'update', rows: [{ index: 0, ok: true }, { index: 1, ok: false, error: 'amount: changed-since' }] }, t)).toBe(
+      'changed 1 records.\nrow 2: amount: changed-since'
+    )
+  })
 })

package/translations/en.json

@@ -252,5 +252,20 @@
   "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"
+  "ai-assistant.workspace.contains-steps": "{count} progress",
+  "ai-assistant.entry.change": "change {count} records",
+  "ai-assistant.entry.changed": "changed {count} records.",
+  "ai-assistant.entry.changed-none": "no record was changed.",
+  "ai-assistant.entry.changes": "{count} records",
+  "ai-assistant.entry.not-changed": "{count} will not be changed",
+  "ai-assistant.entry.record": "record",
+  "ai-assistant.entry.picked": "picked",
+  "ai-assistant.entry.via-current": "the record on screen",
+  "ai-assistant.entry.via-selected": "selected on screen",
+  "ai-assistant.entry.via-id": "found in the conversation",
+  "ai-assistant.entry.issue.record-not-found": "not a record you can see",
+  "ai-assistant.entry.issue.changed-since": "changed since the card was made",
+  "ai-assistant.entry.issue.no-change": "already that value",
+  "ai-assistant.entry.issue.nothing-to-change": "nothing to change",
+  "ai-assistant.entry.issue.not-changeable": "this field cannot be changed - left out"
 }

package/translations/ja.json

@@ -252,5 +252,20 @@
   "ai-assistant.workspace.contains-table": "表 {count}",
   "ai-assistant.workspace.contains-chart": "チャート {count}",
   "ai-assistant.workspace.contains-metrics": "指標 {count}",
-  "ai-assistant.workspace.contains-steps": "経過 {count}"
+  "ai-assistant.workspace.contains-steps": "経過 {count}",
+  "ai-assistant.entry.change": "{count}件を修正",
+  "ai-assistant.entry.changed": "{count}件を修正しました。",
+  "ai-assistant.entry.changed-none": "修正された記録はありません。",
+  "ai-assistant.entry.changes": "{count}件",
+  "ai-assistant.entry.not-changed": "{count}件は修正しません",
+  "ai-assistant.entry.record": "記録",
+  "ai-assistant.entry.picked": "選び方",
+  "ai-assistant.entry.via-current": "表示中の記録",
+  "ai-assistant.entry.via-selected": "選択した行",
+  "ai-assistant.entry.via-id": "会話で見つけた記録",
+  "ai-assistant.entry.issue.record-not-found": "閲覧できる記録ではありません",
+  "ai-assistant.entry.issue.changed-since": "その間に変更されました",
+  "ai-assistant.entry.issue.no-change": "すでにその値です",
+  "ai-assistant.entry.issue.nothing-to-change": "修正する項目がありません",
+  "ai-assistant.entry.issue.not-changeable": "修正できない項目のため除外しました"
 }

package/translations/ko.json

@@ -252,5 +252,20 @@
   "ai-assistant.workspace.contains-table": "표 {count}",
   "ai-assistant.workspace.contains-chart": "차트 {count}",
   "ai-assistant.workspace.contains-metrics": "수치 {count}",
-  "ai-assistant.workspace.contains-steps": "경과 {count}"
+  "ai-assistant.workspace.contains-steps": "경과 {count}",
+  "ai-assistant.entry.change": "{count}건 고치기",
+  "ai-assistant.entry.changed": "{count}건을 고쳤습니다.",
+  "ai-assistant.entry.changed-none": "고친 기록이 없습니다.",
+  "ai-assistant.entry.changes": "{count}건",
+  "ai-assistant.entry.not-changed": "{count}건은 고치지 않습니다",
+  "ai-assistant.entry.record": "기록",
+  "ai-assistant.entry.picked": "고른 길",
+  "ai-assistant.entry.via-current": "보고 있는 기록",
+  "ai-assistant.entry.via-selected": "선택한 행",
+  "ai-assistant.entry.via-id": "대화에서 찾은 기록",
+  "ai-assistant.entry.issue.record-not-found": "볼 수 있는 기록이 아닙니다",
+  "ai-assistant.entry.issue.changed-since": "그사이 바뀌었습니다",
+  "ai-assistant.entry.issue.no-change": "이미 그 값입니다",
+  "ai-assistant.entry.issue.nothing-to-change": "고칠 칸이 없습니다",
+  "ai-assistant.entry.issue.not-changeable": "고칠 수 없는 칸이라 뺐습니다"
 }

package/translations/ms.json

@@ -252,5 +252,20 @@
   "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"
+  "ai-assistant.workspace.contains-steps": "{count} kemajuan",
+  "ai-assistant.entry.change": "ubah {count} rekod",
+  "ai-assistant.entry.changed": "{count} rekod diubah.",
+  "ai-assistant.entry.changed-none": "tiada rekod diubah.",
+  "ai-assistant.entry.changes": "{count} rekod",
+  "ai-assistant.entry.not-changed": "{count} tidak akan diubah",
+  "ai-assistant.entry.record": "rekod",
+  "ai-assistant.entry.picked": "dipilih",
+  "ai-assistant.entry.via-current": "rekod pada skrin",
+  "ai-assistant.entry.via-selected": "dipilih pada skrin",
+  "ai-assistant.entry.via-id": "ditemui dalam perbualan",
+  "ai-assistant.entry.issue.record-not-found": "bukan rekod yang boleh anda lihat",
+  "ai-assistant.entry.issue.changed-since": "telah berubah sejak kad dibuat",
+  "ai-assistant.entry.issue.no-change": "sudah nilai itu",
+  "ai-assistant.entry.issue.nothing-to-change": "tiada yang perlu diubah",
+  "ai-assistant.entry.issue.not-changeable": "medan ini tidak boleh diubah - ditinggalkan"
 }

package/translations/zh.json

@@ -252,5 +252,20 @@
   "ai-assistant.workspace.contains-table": "表格 {count}",
   "ai-assistant.workspace.contains-chart": "图表 {count}",
   "ai-assistant.workspace.contains-metrics": "指标 {count}",
-  "ai-assistant.workspace.contains-steps": "进度 {count}"
+  "ai-assistant.workspace.contains-steps": "进度 {count}",
+  "ai-assistant.entry.change": "修改{count}条",
+  "ai-assistant.entry.changed": "已修改{count}条。",
+  "ai-assistant.entry.changed-none": "未修改任何记录。",
+  "ai-assistant.entry.changes": "{count}条",
+  "ai-assistant.entry.not-changed": "{count}条不会修改",
+  "ai-assistant.entry.record": "记录",
+  "ai-assistant.entry.picked": "选取方式",
+  "ai-assistant.entry.via-current": "当前查看的记录",
+  "ai-assistant.entry.via-selected": "已选中的行",
+  "ai-assistant.entry.via-id": "在对话中找到",
+  "ai-assistant.entry.issue.record-not-found": "不是您可以查看的记录",
+  "ai-assistant.entry.issue.changed-since": "在此期间已被修改",
+  "ai-assistant.entry.issue.no-change": "已是该值",
+  "ai-assistant.entry.issue.nothing-to-change": "没有要修改的字段",
+  "ai-assistant.entry.issue.not-changeable": "此字段不可修改，已忽略"
 }