@things-factory/ai-assistant 10.1.87 → 10.1.90

package/client/components/assistant-chat.ts

@@ -63,6 +63,8 @@ import { chatDefaults } from './chat-defaults.js'
 import { isDifferentConversation, resolveConversation, type AssistantMode, type AssistantModeView, pickInitialMode } from './assistant-mode.js'
 import { parseProposalOutcomeLine, parseProposalRequestLine, proposalCardState, type ParsedProposalOutcome } from './proposal-outcome-line.js'
 import { availableTriggers, type TriggerChip } from './chat-triggers.js'
+import './entry-review.js'
+import { entryReadyCount, isEntryProposal, latestEntryKeys } from '../utils/entry-proposal.js'
 
 interface ChatLine {
   role: 'user' | 'assistant' | 'system'
@@ -3945,12 +3947,17 @@ export class OxAssistantChat extends LitElement {
     /* The card's state is the conversation's rows - read once for every card of this line. */
     const outcomes = this.proposalOutcomes
     const requested = this.proposalRequests
+    /* A data entry card replaced by a newer one for the same record cannot be entered (design/ai/data-entry.md §5). */
+    const latestEntry = items.some(isEntryProposal) ? latestEntryKeys(this.lines.map(one => one.proposals ?? [])) : undefined
     return html`
       <div class="proposals">
         ${items.map(p => {
           const key = this.proposalKey(p)
           const card = proposalCardState(key, { outcomes, requested, sentHere: this.sentProposals.has(key) })
-          const sent = card.state !== 'ready'
+          const entry = isEntryProposal(p)
+          const replaced = entry && latestEntry?.get(p.target) !== key && card.state === 'ready'
+          const ready = entry ? entryReadyCount(p) : 0
+          const sent = card.state !== 'ready' || replaced || (entry && ready === 0)
           /*
             Follow-up chips are the host's words, never this component's. The fallback that used
             to live here named a 3D modeller's operations in hardcoded Korean, and it reached the
@@ -3962,7 +3969,7 @@ export class OxAssistantChat extends LitElement {
             <div class="proposal ${sent ? 'sent' : ''}">
               <md-icon>${p.icon || (p.source ? 'view_in_ar' : 'bolt')}</md-icon>
               <span class="pbody">
-                <span class="plabel">${p.label || p.command}</span>
+                <span class="plabel">${entry && p.labelKey ? i18next.t(p.labelKey) : p.label || p.command}</span>
                 ${p.reason ? html`<span class="preason">${p.reason}</span>` : nothing}
               </span>
               ${/*
@@ -3984,9 +3991,15 @@ export class OxAssistantChat extends LitElement {
                       class="run"
                       ?disabled=${sent}
                       @click=${() => this.executeProposal(p, key)}>
-                      ${sent
-                        ? this.proposalStateText(key)
-                        : i18next.t('ai-assistant.button.run-proposal', { defaultValue: 'run' })}
+                      ${replaced
+                        ? i18next.t('ai-assistant.entry.replaced', { defaultValue: 'replaced by a newer card' })
+                        : card.state !== 'ready'
+                          ? this.proposalStateText(key)
+                          : entry
+                            ? ready
+                              ? i18next.t('ai-assistant.entry.enter', { defaultValue: 'enter {count} rows', count: ready })
+                              : i18next.t('ai-assistant.entry.nothing-to-enter', { defaultValue: 'nothing to enter' })
+                            : i18next.t('ai-assistant.button.run-proposal', { defaultValue: 'run' })}
                     </button>
                   `}
               ${/*
@@ -4002,6 +4015,7 @@ export class OxAssistantChat extends LitElement {
                 </span>
               ` : nothing}
             </div>
+            ${entry ? html`<ox-assistant-entry-review .proposal=${p}></ox-assistant-entry-review>` : nothing}
             ${rawChoices.length ? html`
               <div class="proposal-choices" role="group" aria-label=${i18next.t('ai-assistant.text.proposal-choices', { defaultValue: 'follow-up choices' })}>
                 ${rawChoices.map((c: any) => html`

package/client/components/assistant-dock.ts

@@ -29,7 +29,8 @@ import {
   type AnchorResult,
   type AssistantSurface
 } from '../utils/assistant-surface.js'
-import { runProposal, type ProposalContext, type ProposalOutcome } from '../utils/assistant-proposals.js'
+import { runProposal, setEntryProposalHandler, type ProposalContext, type ProposalOutcome } from '../utils/assistant-proposals.js'
+import { entryProposalHandler, type EntryApplyAnswer } from '../utils/entry-proposal.js'
 import { holdAssistantAsk, subscribeAssistantAsk, takeAssistantAsk, type AssistantAsk } from '../utils/assistant-ask.js'
 import { surfaceTransition } from '../utils/assistant-navigation.js'
 
@@ -38,6 +39,25 @@ export const ASSISTANT_DOCK_VIEWPART = 'assistant-dock'
 const t = (key: string, defaultValue: string, options: Record<string, unknown> = {}) =>
   i18next.t(`ai-assistant.dock.${key}`, { defaultValue, ...options })
 
+/* Pressing a data entry card asks the server to enter the rows it stored - the screen sends none (design/ai/data-entry.md §4). */
+setEntryProposalHandler(
+  entryProposalHandler(
+    async (sessionId, proposalKey) => {
+      const result = await client.mutate({
+        mutation: gql`
+          mutation ($id: String!, $key: String!) {
+            applyEntryProposal(sessionId: $id, proposalKey: $key)
+          }
+        `,
+        variables: { id: sessionId, key: proposalKey }
+      })
+      if (result.errors?.length) throw new Error(result.errors[0].message)
+      return result.data?.applyEntryProposal as EntryApplyAnswer
+    },
+    (key, options) => String(i18next.t(key, options))
+  )
+)
+
 const MODES_QUERY = gql`
   query ($subject: String!) {
     assistantModes(subject: $subject) {
@@ -165,8 +185,19 @@ export class AssistantDock extends localize(i18next)(LitElement) {
        * only in the list (2026-09-30: open and private were one grey word apart, and an owner's question about
        * the books sat in every employee's list). A private one draws nothing extra: it is the default.
        */
+      /*
+       * One warning colour in every application (2026-09-30, product owner): the theme's tertiary was a pale
+       * lavender in figure and something else in each app, so "everyone reads this" was as loud as the theme
+       * happened to be. Amber with near-black ink reads on light and dark themes alike - ink on amber 8.2:1, the edge 3.3:1 on white and 5.1:1 on a dark surface.
+       */
+      :host {
+        --assistant-open-edge: #c47f00;
+        --assistant-open-surface: #f2b01e;
+        --assistant-open-ink: #2e2100;
+      }
+
       :host([audience='open']) {
-        border-left: 3px solid var(--md-sys-color-tertiary);
+        border-left: 4px solid var(--assistant-open-edge);
       }
 
       .audience {
@@ -175,9 +206,9 @@ export class AssistantDock extends localize(i18next)(LitElement) {
         gap: 6px;
         flex: none;
         padding: 6px 10px;
-        background: var(--md-sys-color-tertiary-container);
-        color: var(--md-sys-color-on-tertiary-container);
-        border-bottom: 1px solid var(--md-sys-color-tertiary);
+        background: var(--assistant-open-surface);
+        color: var(--assistant-open-ink);
+        border-bottom: 1px solid var(--assistant-open-edge);
         font-size: 12px;
         font-weight: 600;
         line-height: 1.35;

package/client/components/assistant-session-manager.ts

@@ -56,8 +56,10 @@ export class AssistantSessionManager extends LitElement {
     /* Open and private must part at a glance - an open row is read by everyone in the domain (2026-09-30). */
     .audience { display: inline-flex; align-items: center; gap: 3px; vertical-align: middle; }
     .audience md-icon { --md-icon-size: 14px; }
-    .audience.open { padding: 1px 6px 1px 4px; border-radius: 6px; background: var(--md-sys-color-tertiary-container); color: var(--md-sys-color-on-tertiary-container); font-weight: 600; }
-    .row.open-audience { box-shadow: inset 3px 0 0 var(--md-sys-color-tertiary); }
+    /* The dock's warning colour, fixed across applications - see assistant-dock.ts. */
+    :host { --assistant-open-edge: #c47f00; --assistant-open-surface: #f2b01e; --assistant-open-ink: #2e2100; }
+    .audience.open { padding: 1px 6px 1px 4px; border-radius: 6px; background: var(--assistant-open-surface); color: var(--assistant-open-ink); font-weight: 600; }
+    .row.open-audience { box-shadow: inset 4px 0 0 var(--assistant-open-edge); }
     .actions summary { cursor: pointer; padding: 8px; font-size: 18px; list-style: none; }
     .actions[open] .acts { display: flex; flex-direction: column; position: absolute; right: 10px; top: 40px; z-index: 2; min-width: 180px; padding: 6px; background: var(--md-sys-color-surface-container-lowest); border: 1px solid var(--md-sys-color-outline-variant); border-radius: 8px; box-shadow: 0 4px 16px #0002; }
     .actions button.icon { min-height: 40px; padding: 8px 12px; font: inherit; text-align: start; }

package/client/components/entry-review.ts

@@ -0,0 +1,246 @@
+/*
+ * The rows of a data entry proposal, as the person reviews them (operato-application/design/ai/data-entry.md §5).
+ *
+ * Read-only on purpose: a correction is said in the conversation ("row 2 is 12,000", "drop the last one")
+ * and the model proposes again. What is wrong in a cell is marked on the cell - blocking in the error
+ * colour, a note in the outline - and where each row came from is on the row.
+ */
+import '@material/web/icon/icon.js'
+
+import { LitElement, css, html, nothing } from 'lit'
+import { customElement, property } from 'lit/decorators.js'
+
+import { i18next } from '@operato/i18n'
+
+import { entryCellIssues, entryIssueKey, type EntryIssueView, type EntryRowView, type EntryTotalView } from '../utils/entry-proposal.js'
+
+const SHOWN = 50
+
+const t = (key: string, defaultValue: string, options: Record<string, unknown> = {}) =>
+  i18next.t(`ai-assistant.entry.${key}`, { defaultValue, ...options })
+
+function issueText(issue: EntryIssueView): string {
+  const params = { ...(issue.params ?? {}) } as any
+  if (Array.isArray(params.values)) params.values = params.values.join(', ')
+  return String(i18next.t(entryIssueKey(issue), { defaultValue: issue.code, ...params }))
+}
+
+function shown(value: unknown): string {
+  if (value === undefined || value === null) return ''
+  if (typeof value === 'number') return value.toLocaleString(i18next.language || undefined)
+  if (typeof value === 'boolean') return value ? '✓' : '—'
+  return String(value)
+}
+
+@customElement('ox-assistant-entry-review')
+export class AssistantEntryReview extends LitElement {
+  static styles = css`
+    :host {
+      display: block;
+      margin: 4px 0 2px;
+      font-size: 12px;
+      color: var(--md-sys-color-on-surface);
+    }
+
+    .summary {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 4px 10px;
+      margin-bottom: 6px;
+      color: var(--md-sys-color-on-surface-variant);
+    }
+
+    .summary .blocked {
+      color: var(--md-sys-color-error);
+      font-weight: 600;
+    }
+
+    .scroll {
+      max-height: 320px;
+      overflow: auto;
+      border: 1px solid var(--md-sys-color-outline-variant);
+      border-radius: 6px;
+    }
+
+    table {
+      width: 100%;
+      border-collapse: collapse;
+    }
+
+    th,
+    td {
+      padding: 4px 6px;
+      border-bottom: 1px solid var(--md-sys-color-outline-variant);
+      text-align: start;
+      vertical-align: top;
+      white-space: nowrap;
+    }
+
+    th {
+      position: sticky;
+      top: 0;
+      background: var(--md-sys-color-surface-container);
+      font-weight: 600;
+    }
+
+    td.num {
+      text-align: end;
+      font-variant-numeric: tabular-nums;
+    }
+
+    tr.blocked td {
+      background: color-mix(in srgb, var(--md-sys-color-error) 6%, transparent);
+    }
+
+    td.bad {
+      color: var(--md-sys-color-error);
+      text-decoration: underline wavy var(--md-sys-color-error);
+      text-underline-offset: 3px;
+    }
+
+    td.note {
+      text-decoration: underline dotted var(--md-sys-color-outline);
+      text-underline-offset: 3px;
+    }
+
+    .missing {
+      color: var(--md-sys-color-error);
+      font-style: italic;
+    }
+
+    .source {
+      color: var(--md-sys-color-on-surface-variant);
+      max-width: 180px;
+      overflow: hidden;
+      text-overflow: ellipsis;
+    }
+
+    .row-issue {
+      display: block;
+      color: var(--md-sys-color-on-surface-variant);
+      white-space: normal;
+    }
+
+    .row-issue.blocking {
+      color: var(--md-sys-color-error);
+    }
+
+    .verified {
+      color: var(--md-sys-color-primary);
+    }
+
+    .verified md-icon,
+    .totals md-icon {
+      --md-icon-size: 14px;
+      vertical-align: -2px;
+    }
+
+    .totals {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 2px 12px;
+      margin: 6px 0 0;
+      font-variant-numeric: tabular-nums;
+    }
+
+    .totals .differs {
+      color: var(--md-sys-color-error);
+      font-weight: 600;
+    }
+
+    .totals .matches {
+      color: var(--md-sys-color-primary);
+    }
+
+    .more,
+    .check-failed {
+      margin-top: 4px;
+      color: var(--md-sys-color-on-surface-variant);
+    }
+  `
+
+  @property({ attribute: false }) proposal: any
+
+  /** The sum of each totalled field, beside the total the material prints - a missing row shows here without reading every row. */
+  private renderTotals(totals: EntryTotalView[], columns: { name: string; labelKey?: string }[]) {
+    if (!totals.length) return nothing
+    const name = (field: string) => {
+      const column = columns.find(one => one.name === field)
+      return column?.labelKey ? i18next.t(column.labelKey) : field
+    }
+    return html`<div class="totals" role="status">
+      ${totals.map(total => html`
+        <span>${t('total', '{field} total {sum}', { field: name(total.field), sum: shown(total.all) })}</span>
+        ${total.ready !== total.all ? html`<span>${t('total-ready', 'entered {sum}', { sum: shown(total.ready) })}</span>` : nothing}
+        ${total.declared !== undefined
+          ? html`<span>${t('total-declared', 'the material says {sum}', { sum: shown(total.declared) })}${total.declaredFound === false ? ` (${t('total-not-found', 'not found in the file')})` : ''}</span>
+              ${total.difference
+                ? html`<span class="differs">${t('total-differs', 'differs by {sum}', { sum: shown(total.difference) })}</span>`
+                : html`<span class="matches"><md-icon>task_alt</md-icon> ${t('total-matches', 'matches')}</span>`}`
+          : nothing}
+      `)}
+    </div>`
+  }
+
+  render() {
+    const p = this.proposal ?? {}
+    const columns: { name: string; type: string; required?: boolean; labelKey?: string }[] = p.columns ?? []
+    const rows: EntryRowView[] = p.rows ?? []
+    const counts = p.counts ?? {}
+    return html`
+      <div class="summary" role="status">
+        <span>${t('rows', '{count} rows', { count: counts.rows ?? rows.length })}</span>
+        <span>${t('ready', '{count} ready', { count: counts.ready ?? 0 })}</span>
+        ${counts.blocked ? html`<span class="blocked">${t('blocked', '{count} will not be entered', { count: counts.blocked })}</span>` : nothing}
+        ${counts.cut ? html`<span class="blocked">${t('cut', '{count} left out over the limit', { count: counts.cut })}</span>` : nothing}
+        ${counts.verified ? html`<span class="verified"><md-icon>task_alt</md-icon> ${t('verified', '{count} found in their file', { count: counts.verified })}</span>` : nothing}
+        ${counts.unmatched ? html`<span class="blocked">${t('unmatched', '{count} with a value their file does not have', { count: counts.unmatched })}</span>` : nothing}
+      </div>
+      <div class="scroll">
+        <table>
+          <thead>
+            <tr>
+              <th>#</th>
+              ${columns.map(column => html`<th>${column.labelKey ? i18next.t(column.labelKey) : column.name}${column.required ? ' *' : ''}</th>`)}
+              <th>${t('source', 'from')}</th>
+            </tr>
+          </thead>
+          <tbody>
+            ${rows.slice(0, SHOWN).map(row => {
+              const blocked = (row.issues ?? []).some(issue => issue.blocking)
+              const whole = entryCellIssues(row)
+              return html`
+                <tr class=${blocked ? 'blocked' : ''}>
+                  <td class="num">${row.index + 1}</td>
+                  ${columns.map(column => {
+                    const issues = entryCellIssues(row, column.name)
+                    const bad = issues.some(issue => issue.blocking)
+                    const value = row.values?.[column.name]
+                    const text = shown(value)
+                    return html`<td
+                      class="${column.type === 'number' || column.type === 'integer' ? 'num' : ''} ${bad ? 'bad' : issues.length ? 'note' : ''}"
+                      title=${issues.map(issueText).join('\n')}
+                    >
+                      ${text || (issues.some(issue => issue.code === 'required') ? html`<span class="missing">${t('missing', 'missing')}</span>` : '')}
+                    </td>`
+                  })}
+                  <td class="source" title=${(row.sources ?? []).map(source => source.where || source.attachmentId).join(' · ')}>
+                    ${row.evidence ? html`<span class="verified" title=${t('evidence', 'found on line {line} of the file', { line: row.evidence.line })}><md-icon>task_alt</md-icon></span> ` : nothing}
+                    ${(row.sources ?? []).map(source => source.where || source.attachmentId).join(' · ')}
+                    ${whole
+                      .filter(issue => issue.code !== 'no-source')
+                      .map(issue => html`<span class="row-issue ${issue.blocking ? 'blocking' : ''}">${issueText(issue)}</span>`)}
+                    ${whole.some(issue => issue.code === 'no-source') ? html`<span class="row-issue">${issueText({ code: 'no-source', blocking: false })}</span>` : nothing}
+                  </td>
+                </tr>
+              `
+            })}
+          </tbody>
+        </table>
+      </div>
+      ${this.renderTotals(p.totals ?? [], columns)}
+      ${rows.length > SHOWN ? html`<div class="more">${t('more-rows', '{count} more rows are not shown - they are entered too.', { count: rows.length - SHOWN })}</div>` : nothing}
+      ${p.checkFailed ? html`<div class="check-failed">${t('check-failed', 'the application could not check these rows; they are checked again when entered.')}</div>` : nothing}
+    `
+  }
+}

package/client/utils/assistant-proposals.ts

@@ -37,9 +37,19 @@ export function proposalHandlerOf(tool: string | undefined): ProposalHandler | u
   return tool ? handlers.get(tool) : undefined
 }
 
+/*
+ * Data entry cards are the framework's, whatever record they enter (design/ai/data-entry.md §5): one
+ * handler asks the server to enter the stored rows. The dock sets it; no app registers one per record.
+ */
+let entryHandler: ProposalHandler | undefined
+
+export function setEntryProposalHandler(handler: ProposalHandler): void {
+  entryHandler = handler
+}
+
 /** Runs the proposal - never throws; a failure is a `refused` outcome with its message as the code. */
 export async function runProposal(proposal: any, context: ProposalContext): Promise<ProposalOutcome> {
-  const handler = proposalHandlerOf(proposal?.tool)
+  const handler = proposal?.kind === 'entry' && entryHandler ? entryHandler : proposalHandlerOf(proposal?.tool)
   if (!handler) return { verdict: 'unavailable', errorCode: 'unknown-proposal-kind' }
   try {
     const outcome = await handler(proposal, context)

package/client/utils/entry-proposal.ts

@@ -0,0 +1,103 @@
+/*
+ * The data entry card's rules and its handler (operato-application/design/ai/data-entry.md §5).
+ *
+ * The card is a review, not an editor: a correction is said in the conversation and the model proposes
+ * again - the newer card replaces the older one. Pressing asks the server to enter the stored rows; the
+ * screen sends no rows of its own.
+ */
+import type { ProposalContext, ProposalOutcome } from './assistant-proposals.js'
+
+export interface EntryIssueView {
+  field?: string
+  code: string
+  messageKey?: string
+  params?: Record<string, unknown>
+  blocking: boolean
+}
+
+export interface EntryRowView {
+  index: number
+  values: Record<string, unknown>
+  sources: { attachmentId?: string; where?: string }[]
+  issues: EntryIssueView[]
+  /** The server found this row's numbers and dates together on this line of the cited file. */
+  evidence?: { attachmentId: string; line: number }
+}
+
+export interface EntryTotalView {
+  field: string
+  all: number
+  ready: number
+  declared?: number
+  declaredFound?: boolean
+  difference?: number
+}
+
+export interface EntryRowResult {
+  index: number
+  ok: boolean
+  id?: string
+  label?: string
+  error?: string
+}
+
+export interface EntryApplyAnswer extends ProposalOutcome {
+  rows?: EntryRowResult[]
+}
+
+export function isEntryProposal(proposal: any): boolean {
+  return proposal?.kind === 'entry' && Array.isArray(proposal?.rows)
+}
+
+export function entryReadyCount(proposal: any): number {
+  return (proposal?.rows ?? []).filter((row: EntryRowView) => !row.issues?.some(issue => issue.blocking)).length
+}
+
+/** The i18n key of an issue - the target's own, or the framework's by code. */
+export function entryIssueKey(issue: EntryIssueView): string {
+  return issue.messageKey || `ai-assistant.entry.issue.${issue.code}`
+}
+
+/** The issues of one cell, and of the row as a whole (no field). */
+export function entryCellIssues(row: EntryRowView, field?: string): EntryIssueView[] {
+  return (row.issues ?? []).filter(issue => (field ? issue.field === field : !issue.field))
+}
+
+/** What stays in the conversation - the model reads it on its next turn, and the person sees what went in. */
+export function entryOutcomeNote(answer: EntryApplyAnswer, t: (key: string, options?: any) => string): string {
+  const refused = (answer.rows ?? []).filter(row => !row.ok)
+  const head = answer.applied
+    ? t('ai-assistant.entry.entered', { defaultValue: 'entered {count} rows.', count: answer.applied })
+    : t('ai-assistant.entry.entered-none', { defaultValue: 'no row was entered.' })
+  const lines = refused.slice(0, 20).map(row => t('ai-assistant.entry.row-refused', { defaultValue: 'row {n}: {reason}', n: row.index + 1, reason: row.error || '' }))
+  const more = refused.length > 20 ? [t('ai-assistant.entry.more-refused', { defaultValue: '{count} more rows were not entered.', count: refused.length - 20 })] : []
+  return [head, ...lines, ...more].join('\n')
+}
+
+/** The handler every entry card runs - built with the mutation so the rules are tested without a server. */
+export function entryProposalHandler(
+  apply: (sessionId: string, proposalKey: string) => Promise<EntryApplyAnswer>,
+  t: (key: string, options?: any) => string
+) {
+  return async (proposal: any, context: ProposalContext): Promise<ProposalOutcome> => {
+    if (!context.sessionId || !proposal?.key) return { verdict: 'unavailable', errorCode: 'no-conversation' }
+    const answer = await apply(context.sessionId, proposal.key)
+    return {
+      verdict: answer.verdict,
+      ...(answer.errorCode ? { errorCode: answer.errorCode } : {}),
+      applied: answer.applied ?? 0,
+      missed: answer.missed ?? 0,
+      note: entryOutcomeNote(answer, t)
+    }
+  }
+}
+
+/**
+ * The newest card per record, over the conversation's proposals in order - an older one is replaced and
+ * cannot be entered (the server refuses it as `superseded`; the card says so before anyone presses).
+ */
+export function latestEntryKeys(proposalsInOrder: any[][]): Map<string, string> {
+  const latest = new Map<string, string>()
+  for (const list of proposalsInOrder) for (const one of list ?? []) if (isEntryProposal(one) && one.key) latest.set(one.target, one.key)
+  return latest
+}

package/dist-client/components/assistant-chat.d.ts

@@ -20,6 +20,7 @@ import { LitElement } from 'lit';
 import './mention-popup.js';
 import { type FilterResult } from './mention-popup.js';
 import { type AssistantMode } from './assistant-mode.js';
+import './entry-review.js';
 export interface ChatAttachment {
     id: string;
     file: File;

package/dist-client/components/assistant-chat.js

@@ -47,6 +47,8 @@ import { chatDefaults } from './chat-defaults.js';
 import { isDifferentConversation, resolveConversation, pickInitialMode } from './assistant-mode.js';
 import { parseProposalOutcomeLine, parseProposalRequestLine, proposalCardState } from './proposal-outcome-line.js';
 import { availableTriggers } from './chat-triggers.js';
+import './entry-review.js';
+import { entryReadyCount, isEntryProposal, latestEntryKeys } from '../utils/entry-proposal.js';
 function formatFileSize(bytes) {
     if (!bytes || bytes < 1024)
         return `${bytes || 0} B`;
@@ -3500,12 +3502,17 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
         /* The card's state is the conversation's rows - read once for every card of this line. */
         const outcomes = this.proposalOutcomes;
         const requested = this.proposalRequests;
+        /* A data entry card replaced by a newer one for the same record cannot be entered (design/ai/data-entry.md §5). */
+        const latestEntry = items.some(isEntryProposal) ? latestEntryKeys(this.lines.map(one => one.proposals ?? [])) : undefined;
         return html `
       <div class="proposals">
         ${items.map(p => {
             const key = this.proposalKey(p);
             const card = proposalCardState(key, { outcomes, requested, sentHere: this.sentProposals.has(key) });
-            const sent = card.state !== 'ready';
+            const entry = isEntryProposal(p);
+            const replaced = entry && latestEntry?.get(p.target) !== key && card.state === 'ready';
+            const ready = entry ? entryReadyCount(p) : 0;
+            const sent = card.state !== 'ready' || replaced || (entry && ready === 0);
             /*
               Follow-up chips are the host's words, never this component's. The fallback that used
               to live here named a 3D modeller's operations in hardcoded Korean, and it reached the
@@ -3516,7 +3523,7 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
             <div class="proposal ${sent ? 'sent' : ''}">
               <md-icon>${p.icon || (p.source ? 'view_in_ar' : 'bolt')}</md-icon>
               <span class="pbody">
-                <span class="plabel">${p.label || p.command}</span>
+                <span class="plabel">${entry && p.labelKey ? i18next.t(p.labelKey) : p.label || p.command}</span>
                 ${p.reason ? html `<span class="preason">${p.reason}</span>` : nothing}
               </span>
               ${ /*
@@ -3538,9 +3545,15 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
                       class="run"
                       ?disabled=${sent}
                       @click=${() => this.executeProposal(p, key)}>
-                      ${sent
-                    ? this.proposalStateText(key)
-                    : i18next.t('ai-assistant.button.run-proposal', { defaultValue: 'run' })}
+                      ${replaced
+                    ? i18next.t('ai-assistant.entry.replaced', { defaultValue: 'replaced by a newer card' })
+                    : card.state !== 'ready'
+                        ? this.proposalStateText(key)
+                        : entry
+                            ? ready
+                                ? i18next.t('ai-assistant.entry.enter', { defaultValue: 'enter {count} rows', count: ready })
+                                : i18next.t('ai-assistant.entry.nothing-to-enter', { defaultValue: 'nothing to enter' })
+                            : i18next.t('ai-assistant.button.run-proposal', { defaultValue: 'run' })}
                     </button>
                   `}
               ${ /*
@@ -3556,6 +3569,7 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
                 </span>
               ` : nothing}
             </div>
+            ${entry ? html `<ox-assistant-entry-review .proposal=${p}></ox-assistant-entry-review>` : nothing}
             ${rawChoices.length ? html `
               <div class="proposal-choices" role="group" aria-label=${i18next.t('ai-assistant.text.proposal-choices', { defaultValue: 'follow-up choices' })}>
                 ${rawChoices.map((c) => html `