@things-factory/ai-assistant 10.1.101 → 10.1.103

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/ai-assistant",
-  "version": "10.1.101",
+  "version": "10.1.103",
   "main": "dist-server/index.js",
   "things-factory": true,
   "author": "heartyoh",
@@ -51,5 +51,5 @@
     "copyfiles": "^2.4.1",
     "rimraf": "^5.0.0"
   },
-  "gitHead": "44abc5cac98642b8028b17bf3e019d083539ccab"
+  "gitHead": "db9d51a78d29b96c2c9a5c6a5beac70998aaaeb5"
 }

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'
@@ -355,3 +355,20 @@ describe('a moment', () => {
   })
 })
 
+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, entryGroups, 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 }))

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

@@ -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
 }
@@ -681,3 +683,46 @@ export function entryGroups<T extends { index: number; values: Record<string, un
   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,7 @@ import {
   entryToolName,
   isBlocked,
   normalizeEntryRows,
+  zonedDateTimes,
   entryGroups,
   referenceDoorsOf,
   resolveReferences,
@@ -80,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
@@ -251,6 +252,7 @@ export function entryCategoryOf(target: EntryTarget, run: (context: any) => Grap
     guidance: [
       `- When the person gives material to enter as records (files, photos, pasted text), read all of it first - call readChatAttachment for a file sent in an earlier turn - then call ${name} once with every record as a row.`,
       '- Never invent a value. Leave a field out when the material does not say it; the card marks it, and you ask the person for it.',
+      '- A row kept out because a name was not found, or matches several records, is settled in the conversation: say which name, list the candidates the card names, and ask; then propose again with the name the person chose. The card has no picker - never tell the person to choose on it.',
       '- Give each row its sources: which attachment and where in it, written in the person\'s language. A value the person gave or corrected in the conversation adds the source { person: true }. The server looks for each row\'s numbers and dates in the cited file and marks what it does not find.',
       '- When the material prints a total, always pass it as declaredTotal exactly as printed - do not add it up yourself. The server also reads a total line of a text file itself.',
       `- ${name} only proposes. Nothing is entered until the person presses the button on the card - never say the records were entered.`,

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,