@things-factory/ai-assistant 10.1.100 → 10.1.102

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/ai-assistant",
-  "version": "10.1.100",
+  "version": "10.1.102",
   "main": "dist-server/index.js",
   "things-factory": true,
   "author": "heartyoh",
@@ -51,5 +51,5 @@
     "copyfiles": "^2.4.1",
     "rimraf": "^5.0.0"
   },
-  "gitHead": "e3c2444ded42290fdc77b189f5befa419f575f9b"
+  "gitHead": "8bba629dd321caa7c047d52f451d61d2678cc6e2"
 }

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

@@ -265,3 +265,49 @@ describe('a field that points at another record', () => {
   })
 })
 
+describe('a record with lines', () => {
+  const advice: EntryTarget = {
+    key: 'warehouse.inbound-advice',
+    labelKey: 'x',
+    description: 'one inbound advice line.',
+    mutation: 'mutation ($advice: InboundAdviceInput!) { receiveInboundAdvice(advice: $advice) { name } }',
+    fields: [
+      { name: 'despatchAdvice', type: 'string', required: true },
+      { name: 'epcClass', type: 'string', required: true },
+      { name: 'quantity', type: 'number', required: true }
+    ],
+    group: {
+      by: 'despatchAdvice',
+      variables: rows => ({ advice: { name: rows[0].values.despatchAdvice, lines: rows.map(row => ({ epcClass: row.values.epcClass, quantity: row.values.quantity })) } }),
+      appliedOf: data => ({ id: data?.receiveInboundAdvice?.name })
+    }
+  }
+  const line = (despatchAdvice: string, epcClass: string, quantity: any) => ({ values: { despatchAdvice, epcClass, quantity }, sources: [{ where: 'x' }] })
+
+  it('★ the lines of one record go in by one call; a record with a line kept out stays out whole', async () => {
+    declareEntryTarget(advice)
+    const proposed: any = await proposeEntries(advice, { rows: [line('DA-1', 'A', 20), line('DA-1', 'B', 5), line('DA-2', 'C', 'many'), line('DA-2', 'D', 1)] }, { state: {} }, async () => new Map(), run)
+    expect(proposed.counts).toMatchObject({ rows: 4, groups: 2, groupsReady: 1 })
+    expect(proposed.groupBy).toBe('despatchAdvice')
+    const sent: any[] = []
+    const outcome = await applyEntryProposal('g1', {
+      messages: [{ id: 'm1', proposals: [{ ...proposed, key: 'g1' }] }],
+      answered: false,
+      passesDoor: async () => true,
+      execute: async (_document, variables) => (sent.push(variables), { data: { receiveInboundAdvice: { name: variables.advice.name } } }),
+      state: {}
+    })
+    expect(sent).toEqual([{ advice: { name: 'DA-1', lines: [{ epcClass: 'A', quantity: 20 }, { epcClass: 'B', quantity: 5 }] } }])
+    expect(outcome.rows).toEqual([
+      { index: 0, ok: true, id: 'DA-1' },
+      { index: 1, ok: true, id: 'DA-1' },
+      { index: 2, ok: false, error: 'quantity: not-a-number' },
+      { index: 3, ok: false, error: 'group-kept-out (row 3)' }
+    ])
+  })
+
+  it('a group by a field that is not declared is refused at boot', () => {
+    expect(() => declareEntryTarget({ ...advice, group: { ...advice.group!, by: 'order' } })).toThrow(/group by 'order'/)
+  })
+})
+

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

@@ -2,7 +2,7 @@
  * Data entry from material (design/ai/data-entry.md) - the rules a row passes, what the tool hands back,
  * and what the server asks again before it writes.
  */
-import { clearEntryTargets, declareEntryTarget, entryDoorOf, entryToolName, entryTotals, lineHas, normalizeEntryRows, printedTotalOf, verifyRowsAgainstSources, writtenForms, type EntryTarget } from './entry-target'
+import { offsetAt, zonedDateTimes, clearEntryTargets, declareEntryTarget, entryDoorOf, entryToolName, entryTotals, lineHas, normalizeEntryRows, printedTotalOf, verifyRowsAgainstSources, writtenForms, type EntryTarget } from './entry-target'
 import { entryCategoryOf, proposeEntries } from './entry-tools'
 import { applyEntryProposal, entryProposalAnswered, findEntryProposal, type EntryApplyDeps } from './entry-apply'
 import { modeToolCategories } from '../assistant-mode/resolve'
@@ -341,3 +341,34 @@ describe('the model names the total its own way', () => {
   })
 })
 
+describe('a moment', () => {
+  const shift: EntryTarget = { ...expense, fields: [{ name: 'startTime', type: 'datetime', required: true }] }
+  it('reads the ways a moment is written - without an offset it stays without one', () => {
+    const { rows } = normalizeEntryRows(shift, [
+      { values: { startTime: '2026-10-01 08:30' }, sources: [{ where: 'x' }] },
+      { values: { startTime: '2026.10.1 8:05:09' }, sources: [{ where: 'x' }] },
+      { values: { startTime: '2026-10-01T08:30:00+0900' }, sources: [{ where: 'x' }] },
+      { values: { startTime: '2026-10-01 25:00' }, sources: [{ where: 'x' }] }
+    ])
+    expect(rows.map(row => row.values.startTime)).toEqual(['2026-10-01T08:30:00', '2026-10-01T08:05:09', '2026-10-01T08:30:00+09:00', '2026-10-01 25:00'])
+    expect(rows[3].issues).toEqual([{ field: 'startTime', code: 'not-a-datetime', blocking: true }])
+  })
+})
+
+describe("a moment is the domain's wall time", () => {
+  it('★ a time without an offset gets the domain time zone\'s offset at that day - DST taken at the day, not today', () => {
+    expect(offsetAt('Asia/Seoul', '2026-10-01T08:30:00')).toBe('+09:00')
+    expect(offsetAt('America/New_York', '2026-07-01T08:30:00')).toBe('-04:00')
+    expect(offsetAt('America/New_York', '2026-12-01T08:30:00')).toBe('-05:00')
+    const rows = [{ values: { at: '2026-10-01T08:30:00', other: '2026-10-01T08:30:00+00:00' } }]
+    zonedDateTimes([{ name: 'at', type: 'datetime' }, { name: 'other', type: 'datetime' }], rows, 'Asia/Seoul')
+    expect(rows[0].values).toEqual({ at: '2026-10-01T08:30:00+09:00', other: '2026-10-01T08:30:00+00:00' })
+  })
+
+  it('the tool gives the domain\'s offset to what the model wrote', async () => {
+    const shift: EntryTarget = { ...expense, fields: [{ name: 'startTime', type: 'datetime', required: true }] }
+    const result: any = await proposeEntries(shift, { rows: [{ values: { startTime: '2026-10-01 08:30' }, sources: [{ where: 'x' }] }] }, { state: { domain: { timezone: 'Asia/Seoul' } } }, async () => new Map(), async () => ({}))
+    expect(result.rows[0].values.startTime).toBe('2026-10-01T08:30:00+09:00')
+  })
+})
+

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

@@ -12,7 +12,7 @@
  */
 import { PROPOSAL_OUTCOME_PREFIX, PROPOSAL_VERDICTS } from '../chat-message/proposal-outcome.js'
 import { readRecords, stillAsProposed, type ChangeRow } from './entry-update.js'
-import { changeToolName, resolveReferences, entryDoorOf, entryTargetOf, entryToolName, rootFieldOf, isBlocked, recordEntryEvent, normalizeEntryRows, withCheckedIssues, type EntryRow, type EntryTarget } from './entry-target.js'
+import { changeToolName, zonedDateTimes, entryGroups, resolveReferences, entryDoorOf, entryTargetOf, entryToolName, rootFieldOf, isBlocked, recordEntryEvent, normalizeEntryRows, withCheckedIssues, type EntryRow, type EntryTarget } from './entry-target.js'
 
 export interface StoredProposalMessage {
   id: string
@@ -86,7 +86,7 @@ export async function applyEntryProposal(key: string, deps: EntryApplyDeps, targ
   /* Read again from the stored values - the same rules, and today's records for the target's checks. */
   let { rows } = normalizeEntryRows(target, (proposal.rows ?? []).map((row: EntryRow) => ({ values: row.values, sources: row.sources })))
   /* A reference that was not settled on the card is asked again - never entered as a name. */
-  rows = await resolveReferences(target.fields, rows, deps.execute)
+  rows = await resolveReferences(target.fields, zonedDateTimes(target.fields, rows, deps.state?.domain?.timezone), deps.execute)
   if (target.check) {
     try {
       rows = withCheckedIssues(rows, await target.check(rows, { state: deps.state }))
@@ -97,14 +97,35 @@ export async function applyEntryProposal(key: string, deps: EntryApplyDeps, targ
   }
 
   const results: EntryRowResult[] = []
-  for (const row of rows) {
+  if (target.group) {
+    /* One call per group; a group with a row kept out stays out whole - an order missing a line is not entered. */
+    for (const [, members] of entryGroups(rows, target.group.by)) {
+      const blocked = members.find(isBlocked)
+      if (blocked) {
+        const issue = blocked.issues.find(one => one.blocking)!
+        for (const row of members)
+          results.push({ index: row.index, ok: false, error: row === blocked ? (issue.field ? `${issue.field}: ${issue.code}` : issue.code) : `group-kept-out (row ${blocked.index + 1})` })
+        continue
+      }
+      try {
+        const answer = await deps.execute(target.mutation, target.group.variables(members))
+        const error = answer.errors?.length ? answer.errors.map(one => one.message).join('; ') || 'refused' : undefined
+        const applied = error ? undefined : target.group.appliedOf?.(answer.data, members)
+        for (const row of members) results.push(error ? { index: row.index, ok: false, error } : { index: row.index, ok: true, ...(applied?.id ? { id: applied.id } : {}), ...(applied?.label ? { label: applied.label } : {}) })
+      } catch (error: any) {
+        for (const row of members) results.push({ index: row.index, ok: false, error: error?.message || 'refused' })
+      }
+    }
+    results.sort((a, b) => a.index - b.index)
+  }
+  for (const row of target.group ? [] : rows) {
     if (isBlocked(row)) {
       const issue = row.issues.find(one => one.blocking)!
       results.push({ index: row.index, ok: false, error: issue.field ? `${issue.field}: ${issue.code}` : issue.code })
       continue
     }
     try {
-      const answer = await deps.execute(target.mutation, target.variables(row))
+      const answer = await deps.execute(target.mutation, target.variables!(row))
       if (answer.errors?.length) {
         results.push({ index: row.index, ok: false, error: answer.errors.map(one => one.message).join('; ') || 'refused' })
         continue

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

@@ -14,7 +14,7 @@
  */
 import { parse } from 'graphql'
 
-export type EntryFieldType = 'string' | 'text' | 'number' | 'integer' | 'date' | 'boolean' | 'enum' | 'reference'
+export type EntryFieldType = 'string' | 'text' | 'number' | 'integer' | 'date' | 'datetime' | 'boolean' | 'enum' | 'reference'
 
 export interface EntryField {
   name: string
@@ -68,6 +68,8 @@ export interface EntryIssue {
   code: string
   messageKey?: string
   params?: Record<string, unknown>
+  /** A param that is a code the screen words - { status: 'text.state-' } shows `down` as 고장. */
+  paramKeys?: Record<string, string>
   /** A blocking issue keeps the row out when the person presses the button. */
   blocking: boolean
 }
@@ -127,10 +129,20 @@ export interface EntryTarget {
    * to a person typing it in.
    */
   mutation: string
-  /** The mutation's variables for one row. */
-  variables(row: EntryRow): Record<string, unknown>
+  /** The mutation's variables for one row. Absent when the target enters rows by group (below). */
+  variables?(row: EntryRow): Record<string, unknown>
   /** What the conversation says of an entered row - its id and a short name. */
   appliedOf?(data: any, row: EntryRow): EntryApplied | undefined
+  /**
+   * A record with lines - one order, several item lines. Rows that share the value of `by` (the order number) are one
+   * record, entered by one call of the mutation with `variables(rows)`. If any row of a group is kept out, the whole
+   * group is: an order missing a line must not go in unseen.
+   */
+  group?: {
+    by: string
+    variables(rows: EntryRow[]): Record<string, unknown>
+    appliedOf?(data: any, rows: EntryRow[]): EntryApplied | undefined
+  }
   /** At most this many rows in one proposal. Default 200. */
   maxRows?: number
   /**
@@ -214,7 +226,10 @@ export function declareEntryTarget(target: EntryTarget): void {
   } catch (error: any) {
     throw new Error(`[ai-assistant] entry target '${target.key}': its mutation ${error?.message ?? 'does not parse'}.`)
   }
-  if (typeof target.variables !== 'function') throw new Error(`[ai-assistant] entry target '${target.key}' has no variables.`)
+  if (typeof target.variables !== 'function' && typeof target.group?.variables !== 'function')
+    throw new Error(`[ai-assistant] entry target '${target.key}' has no variables (per row, or per group).`)
+  if (target.group && !target.fields.some(field => field.name === target.group!.by))
+    throw new Error(`[ai-assistant] entry target '${target.key}': group by '${target.group.by}' is not a declared field.`)
   if (target.update) {
     for (const [what, document, operation] of [
       ['update.read', target.update.read?.query, 'query'],
@@ -308,6 +323,22 @@ function toDate(value: unknown): string | undefined {
   return `${match[1]}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`
 }
 
+/**
+ * A moment as `YYYY-MM-DDTHH:mm:ss`, with the offset when it was written - "2026-10-01 08:30", "2026.10.1 8:30",
+ * an ISO string. Without an offset it stays without one: the application reads it in its own time zone, as it
+ * reads a time typed into its own screen.
+ */
+function toDateTime(value: unknown): string | undefined {
+  if (typeof value !== 'string') return undefined
+  const match = value.trim().match(/^(\d{4})[-./](\d{1,2})[-./](\d{1,2})[ T](\d{1,2}):(\d{2})(?::(\d{2})(?:\.\d+)?)?\s*(Z|[+-]\d{2}:?\d{2})?$/)
+  if (!match) return undefined
+  const day = toDate(`${match[1]}-${match[2]}-${match[3]}`)
+  const [hour, minute, second] = [Number(match[4]), Number(match[5]), Number(match[6] ?? 0)]
+  if (!day || hour > 23 || minute > 59 || second > 59) return undefined
+  const offset = match[7] ? (match[7] === 'Z' ? 'Z' : match[7].replace(/^([+-]\d{2})(\d{2})$/, '$1:$2')) : ''
+  return `${day}T${String(hour).padStart(2, '0')}:${match[5]}:${String(second).padStart(2, '0')}${offset}`
+}
+
 function toBoolean(value: unknown): boolean | undefined {
   if (typeof value === 'boolean') return value
   if (typeof value !== 'string') return undefined
@@ -332,6 +363,10 @@ export function readFieldValue(field: EntryField, value: unknown): { read?: unkn
       const read = toDate(value)
       return read === undefined ? { code: 'not-a-date' } : { read }
     }
+    case 'datetime': {
+      const read = toDateTime(value)
+      return read === undefined ? { code: 'not-a-datetime' } : { read }
+    }
     case 'boolean': {
       const read = toBoolean(value)
       return read === undefined ? { code: 'not-a-boolean' } : { read }
@@ -452,6 +487,12 @@ export function writtenForms(type: EntryFieldType, value: unknown): string[] {
     }
     return [...forms].map(form => (negative ? `-${form}` : form))
   }
+  if (type === 'datetime') {
+    /* A moment is found by its day and its hh:mm - the file writes seconds and zones its own way. */
+    const match = typeof value === 'string' ? value.match(/^(\d{4}-\d{2}-\d{2})T(\d{2}):(\d{2})/) : null
+    if (!match) return []
+    return writtenForms('date', match[1])
+  }
   if (type === 'date') {
     const match = typeof value === 'string' ? value.match(/^(\d{4})-(\d{2})-(\d{2})$/) : null
     if (!match) return []
@@ -631,3 +672,57 @@ export async function resolveReferences<T extends { values: Record<string, unkno
   return rows
 }
 
+/** The rows by group, in the order groups first appear - `[key, rows]`. A row without the key is a group of its own. */
+export function entryGroups<T extends { index: number; values: Record<string, unknown> }>(rows: T[], by: string): [string, T[]][] {
+  const groups = new Map<string, T[]>()
+  for (const row of rows) {
+    const value = row.values[by]
+    const key = value === undefined || value === null || value === '' ? `\u0000row-${row.index}` : String(typeof value === 'object' ? (value as any).id ?? (value as any).text : value)
+    groups.set(key, [...(groups.get(key) ?? []), row])
+  }
+  return [...groups.entries()]
+}
+
+/** The UTC offset a time zone has at a wall time - "+09:00". DST is taken at that day, not today. */
+export function offsetAt(timeZone: string | undefined, wall: string): string | undefined {
+  const match = wall.match(/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})$/)
+  if (!match) return undefined
+  const [y, mo, d, h, mi, se] = match.slice(1).map(Number)
+  let format: Intl.DateTimeFormat
+  try {
+    format = new Intl.DateTimeFormat('en-US', { timeZone: timeZone || undefined, timeZoneName: 'longOffset', year: 'numeric' })
+  } catch {
+    return undefined
+  }
+  const minutesOf = (at: number) => {
+    const name = format.formatToParts(new Date(at)).find(part => part.type === 'timeZoneName')?.value ?? 'GMT'
+    const m = name.match(/GMT([+-])(\d{2}):?(\d{2})?/)
+    return m ? (m[1] === '-' ? -1 : 1) * (Number(m[2]) * 60 + Number(m[3] ?? 0)) : 0
+  }
+  /* The offset at the wall time read as UTC, then once more at the instant that gives - right across a DST change. */
+  const asUtc = Date.UTC(y, mo - 1, d, h, mi, se)
+  const minutes = minutesOf(asUtc - minutesOf(asUtc) * 60_000)
+  const sign = minutes < 0 ? '-' : '+'
+  const abs = Math.abs(minutes)
+  return `${sign}${String(Math.floor(abs / 60)).padStart(2, '0')}:${String(abs % 60).padStart(2, '0')}`
+}
+
+/**
+ * A moment written without an offset is the domain's wall time - "08:30" in a factory is 08:30 there. Each such
+ * value gets the domain time zone's offset at that day, so an API taking DateTimeISO accepts it and reads the moment
+ * meant (plant refused every downtime log without it, 2026-10-01).
+ */
+export function zonedDateTimes<T extends { values: Record<string, unknown> }>(fields: EntryField[], rows: T[], timeZone: string | undefined): T[] {
+  const moments = fields.filter(field => field.type === 'datetime')
+  if (!moments.length) return rows
+  for (const row of rows) {
+    for (const field of moments) {
+      const value = row.values[field.name]
+      if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/.test(value)) continue
+      const offset = offsetAt(timeZone, value)
+      if (offset) row.values[field.name] = `${value}${offset}`
+    }
+  }
+  return rows
+}
+

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

@@ -22,6 +22,8 @@ import {
   entryToolName,
   isBlocked,
   normalizeEntryRows,
+  zonedDateTimes,
+  entryGroups,
   referenceDoorsOf,
   resolveReferences,
   recordEntryEvent,
@@ -42,6 +44,7 @@ function fieldSchema(field: EntryField): any {
     field.description,
     field.required ? 'required' : 'optional',
     field.type === 'date' ? 'YYYY-MM-DD' : undefined,
+    field.type === 'datetime' ? 'YYYY-MM-DD HH:mm, with the offset only when the material gives one' : undefined,
     field.type === 'enum' ? `one of: ${field.values!.join(', ')}` : undefined
   ]
     .filter(Boolean)
@@ -78,7 +81,7 @@ export async function proposeEntries(target: EntryTarget, args: any, context: an
   const cited = [...normalized.flatMap(row => row.sources.map(source => source.attachmentId)), declared?.attachmentId].filter((id): id is string => typeof id === 'string' && !!id)
   const texts = cited.length ? await loadTexts(cited, context).catch(() => new Map<string, string>()) : new Map<string, string>()
   /* A name the model wrote for another record is settled to its id by the application's query, as the person. */
-  const resolved = await resolveReferences(target.fields, normalized, run ?? runAsCaller(context))
+  const resolved = await resolveReferences(target.fields, zonedDateTimes(target.fields, normalized, context?.state?.domain?.timezone), run ?? runAsCaller(context))
   const read = verifyRowsAgainstSources(resolved, target.fields, texts)
 
   let rows: EntryRow[] = read
@@ -92,6 +95,9 @@ export async function proposeEntries(target: EntryTarget, args: any, context: an
   }
 
   const blocked = rows.filter(isBlocked).length
+  /* With lines grouped into records, the card counts the records and says which are kept out whole. */
+  const groups = target.group ? entryGroups(rows, target.group.by) : undefined
+  const groupCounts = groups ? { groups: groups.length, groupsReady: groups.filter(([, members]) => !members.some(isBlocked)).length } : {}
   const totals = entryTotals(rows, target.fields, declared, texts)
   const verified = rows.filter(row => row.evidence).length
   const unmatched = rows.filter(row => row.issues.some(issue => issue.code === 'not-in-source')).length
@@ -105,7 +111,8 @@ export async function proposeEntries(target: EntryTarget, args: any, context: an
     icon: 'playlist_add',
     columns: columnsOf(target),
     rows,
-    counts: { rows: rows.length, ready: rows.length - blocked, blocked, cut, verified, unmatched },
+    counts: { rows: rows.length, ready: rows.length - blocked, blocked, cut, verified, unmatched, ...groupCounts },
+    ...(target.group ? { groupBy: target.group.by } : {}),
     ...(totals.length ? { totals } : {}),
     ...(typeof args?.note === 'string' && args.note.trim() ? { reason: args.note.trim().slice(0, 300) } : {}),
     ...(checkFailed ? { checkFailed } : {}),
@@ -191,6 +198,7 @@ export function entryCategoryOf(target: EntryTarget, run: (context: any) => Grap
     doors: [entryDoorOf(target.mutation), ...referenceDoorsOf(target.fields)],
     description:
       `Propose records to enter: ${target.description} ` +
+      (target.group ? `Each row is one line; the rows of one record share the same ${target.group.by}. ` : '') +
       'Pass every record found in the material as one row. The rows are shown to the person as a card; nothing is written until they press it.',
     schema: {
       type: 'object',

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

@@ -14,6 +14,7 @@ import {
   findToolName,
   readFieldValue,
   resolveReferences,
+  zonedDateTimes,
   sameFieldValue,
   type EntryField,
   type EntryIssue,
@@ -147,7 +148,7 @@ export async function proposeChanges(target: EntryTarget, args: any, context: an
   } catch (error: any) {
     return { rejected: true, error: 'read-failed', message: `could not read the records: ${error?.message ?? error}` }
   }
-  const rows = await resolveReferences(changeableFields(target), changeRows(target, picked, records), run)
+  const rows = await resolveReferences(changeableFields(target), zonedDateTimes(changeableFields(target), changeRows(target, picked, records), context?.state?.domain?.timezone), run)
   const blocked = rows.filter(blockedChange).length
   return {
     proposed: true,

package/test/entry-proposal.test.ts

@@ -77,4 +77,15 @@ describe('the entry card', () => {
       'changed 1 records.\nrow 2: amount: changed-since'
     )
   })
+
+  it('★ the button counts only the lines of records that go in whole', () => {
+    const p = { ...card('g'), groupBy: 'order', rows: [
+      { index: 0, values: { order: 'A' }, sources: [], issues: [] },
+      { index: 1, values: { order: 'A' }, sources: [], issues: [] },
+      { index: 2, values: { order: 'B' }, sources: [], issues: [] },
+      { index: 3, values: { order: 'B' }, sources: [], issues: [{ code: 'required', field: 'qty', blocking: true }] }
+    ] }
+    expect(entryReadyCount(p)).toBe(2)
+  })
 })
+

package/translations/en.json

@@ -273,5 +273,7 @@
   "ai-assistant.entry.issue.reference-not-found": "\"{text}\" - not found",
   "ai-assistant.entry.issue.reference-ambiguous": "\"{text}\" - matches several: {candidates}",
   "ai-assistant.entry.issue.reference-unreadable": "\"{text}\" - could not be looked up",
-  "ai-assistant.entry.issue.not-a-reference": "not a record it can point to"
+  "ai-assistant.entry.issue.not-a-reference": "not a record it can point to",
+  "ai-assistant.entry.groups": "{count} records",
+  "ai-assistant.entry.groups-kept-out": "{count} records kept out whole"
 }

package/translations/ja.json

@@ -273,5 +273,7 @@
   "ai-assistant.entry.issue.reference-not-found": "「{text}」— 見つかりません",
   "ai-assistant.entry.issue.reference-ambiguous": "「{text}」— 複数に一致: {candidates}",
   "ai-assistant.entry.issue.reference-unreadable": "「{text}」— 検索できませんでした",
-  "ai-assistant.entry.issue.not-a-reference": "参照先の記録が分かりません"
+  "ai-assistant.entry.issue.not-a-reference": "参照先の記録が分かりません",
+  "ai-assistant.entry.groups": "{count}件",
+  "ai-assistant.entry.groups-kept-out": "{count}件は行が止まり全体を入力しません"
 }

package/translations/ko.json

@@ -273,5 +273,7 @@
   "ai-assistant.entry.issue.reference-not-found": "\"{text}\" — 찾지 못했습니다",
   "ai-assistant.entry.issue.reference-ambiguous": "\"{text}\" — 여럿과 맞습니다: {candidates}",
   "ai-assistant.entry.issue.reference-unreadable": "\"{text}\" — 찾아보지 못했습니다",
-  "ai-assistant.entry.issue.not-a-reference": "가리키는 기록을 알 수 없습니다"
+  "ai-assistant.entry.issue.not-a-reference": "가리키는 기록을 알 수 없습니다",
+  "ai-assistant.entry.groups": "{count}건",
+  "ai-assistant.entry.groups-kept-out": "{count}건은 줄이 막혀 통째로 입력하지 않습니다"
 }

package/translations/ms.json

@@ -273,5 +273,7 @@
   "ai-assistant.entry.issue.reference-not-found": "\"{text}\" - tidak ditemui",
   "ai-assistant.entry.issue.reference-ambiguous": "\"{text}\" - sepadan dengan beberapa: {candidates}",
   "ai-assistant.entry.issue.reference-unreadable": "\"{text}\" - tidak dapat dicari",
-  "ai-assistant.entry.issue.not-a-reference": "bukan rekod yang boleh dirujuk"
+  "ai-assistant.entry.issue.not-a-reference": "bukan rekod yang boleh dirujuk",
+  "ai-assistant.entry.groups": "{count} rekod",
+  "ai-assistant.entry.groups-kept-out": "{count} rekod ditahan sepenuhnya"
 }

package/translations/zh.json

@@ -273,5 +273,7 @@
   "ai-assistant.entry.issue.reference-not-found": "\"{text}\" — 未找到",
   "ai-assistant.entry.issue.reference-ambiguous": "\"{text}\" — 匹配多个：{candidates}",
   "ai-assistant.entry.issue.reference-unreadable": "\"{text}\" — 无法查找",
-  "ai-assistant.entry.issue.not-a-reference": "无法确定所指记录"
+  "ai-assistant.entry.issue.not-a-reference": "无法确定所指记录",
+  "ai-assistant.entry.groups": "{count}条",
+  "ai-assistant.entry.groups-kept-out": "{count}条因有行被拦而整体不录入"
 }