@lotics/ui 7.19.3 → 8.0.0

package/AGENTS.md

@@ -153,18 +153,22 @@ Pick by capability, not by name. (→ the source file for the API.)
 - **AI surfaces** — `Composer` (the adaptive command/chat composer — a compact pill when empty that
   expands for long text + attachments; the surface that triggers agent work),
   `AgentRun` (the live streaming work feed) + `AgentProgress` (its compact, floating, expandable
-  form — a composer's "working" state), `ReviewCard` (THE single-proposal review card — compositional
-  body via `children`: a `RecordFields` record (header-first) or a `MatchSides` pairing (body-first))
-  + `Confidence`; `ChangeReview` (the BATCH review list — whole-set OR 1-by-1; compositional via
-  `renderItem`, with `ChangeDiff` for the before→after body) + `ChangeReviewActions` (its commit bar,
-  pinned by the host in a `DialogFooter`/`DrawerFooter` or inline),
+  form — a composer's "working" state) + `Confidence`;
+  **`ChangeReview` — THE one review-before-apply surface, a COMPOUND family** (frame: `ChangeReview`
+  · `ChangeReviewHeader` · `ChangeReviewActions`; sections: `Change` · `ChangeLabel` ·
+  `ChangeSummary` · `ChangeReasoning`; the grammar: `ChangeFields` + `ChangeField` ·
+  `ChangeRecord` · `ChangeBand` + `ChangeValueInput`): adds, updates, removals, conflicts, whole
+  records, display-only findings are all compositions — see §AI workflows for the laws;
   `Clarify` (the agent asks back — selectable `ChoiceList` options),
-  `Sources` (provenance chips for AI output). For STRUCTURED AI output the review
-  surfaces above don't cover: `SpecList` (the "exact breakdown" — a labeled-value spec sheet, the
-  panel of an answer),
-  `Finding` (one ranked briefing/audit insight — severity + metric + sources + action), `Discrepancy`
-  (a field whose value disagrees across sources — pick the truth), `TriageRow` (an incoming item the
-  agent classified + routed), `ScoredOption` (an AI-ranked candidate — score + rationale + specs).
+  `Sources` (provenance chips for AI output — at review scale, `label={null}` slots the chips at a
+  section's bottom), `Finding` (one ranked insight from an AI check — localized severity word ·
+  title · detail · `Sources` chips · a `children` slot; **`FindingComparison`** is the
+  expected-vs-actual body: each disagreeing side a labeled row, the DELTA emphasized under a
+  hairline (localized "Difference") — quantities, totals, dates; a plain `metric` prop remains for
+  one-number findings. The children slot composes ANY visual result — a compact `Table` for
+  per-line detail (danger color on the offending cells), `ProgressBar` for
+  consumption-toward-a-cliff (free time, credit), dot `Badge`s for a present/missing checklist,
+  `Confidence` for judgment calls — the AI-page demos show each. Display-only — it informs the verdict the host records; `finding` slice).
   See §AI workflows.
 
 ---
@@ -406,6 +410,27 @@ accepts / edits / dismisses, the deterministic app applies. The agent owns judgm
 (recognition, estimation, intent→parameters); the app owns geometry, math, and the write.
 Compose the surfaces as a loop, and reach for the right one by job:
 
+**Which AI surface — decide by the OUTCOME's shape, not the task's topic.** Three shapes:
+
+1. **Field writes** (extract, match, rank, classify → the record changes) → **in-app agent**
+   (`useAgentRun`) + **`ChangeReview`**. The commits must obey the diff law (Keep/Drop per
+   change, app-workflow writes, bounded app authority), and the operator wants one button +
+   a review — never a prompt box.
+2. **Evidence for an in-app decision** (cross-check, audit, tie-out → nothing is written; the
+   operator acts on what was found) → **in-app agent** + **`Finding`**. Still bounded and
+   prompt-free (an optional instructions brief at most): the brief is fixed, the output is
+   structured display-only findings read IN the record's context, and there is no conversation
+   to have — the loop closes when the operator acts in the app. Chat would add prompting and
+   tear the findings away from the record they judge.
+3. **A file or an open-ended answer** (edit this document, draft from context, explain) →
+   **hand off to the chat agent** (`askAi` in `@lotics/app-sdk`). The loop is multi-turn with
+   no output schema, judged by looking — and the chat harness already owns it: preview beside
+   the thread, version chains, branching, session memory. An in-app "edit chat" would
+   re-implement all of that inside every app.
+
+The Document desk's Use-AI fork IS this table as UI: Extract data (1) · Cross-check (2) ·
+Edit with AI (3) — one entry point, three outcome shapes.
+
 - **Command / compose** — `Composer`, the adaptive command surface. Empty + minimal (no `footerRight`
   model picker, no `pills`, no `files`), it's a COMPACT PILL: an optional `actionsButton` (attach) left,
   the input, a send arrow right (Enter sends, Shift+Enter for a newline) — the same geometry
@@ -439,28 +464,47 @@ Compose the surfaces as a loop, and reach for the right one by job:
   free — no hand-assembly). Transparent work, NEVER a bare spinner. On a canvas/composer app reach for
   `AgentProgress` — `AgentRun` collapsed into a floating pill (avatar + current step) that EXPANDS on
   press; the composer morphs into it while running, and reveals again when done.
-- **Review before apply — ONE card + the batch engine, the BODY is compositional.** Every "the agent
-  proposes → the human accepts / edits / dismisses → nothing auto-applies" surface wears the same
-  `reviewCardStyle` + an optional `Confidence`. There are two primitives:
-  - **`ReviewCard`** — THE single-proposal review card. It owns the chrome (eyebrow + `Confidence`,
-    rationale, a generic `actions` footer — Accept/Edit/Dismiss, Confirm/Remove, Accept/Reassign,
-    whatever the verbs are — and a collapse-to-a-row resolved state); the BODY is `children`. **Layout
-    follows the props**: give it an `eyebrow`/`title` and the chrome LEADS (header-first — a value or
-    record proposal, e.g. a `RecordFields` → `tpl_extract`); give it only `children` and the BODY leads,
-    the confidence + reason beneath it (body-first — a `MatchSides` pairing where the link is the hero
-    → `tpl_match`). Stack several (rank by confidence) for a shortlist or a document's records.
-  - **`ChangeReview`** — THE batch engine for a SET you decide each then commit together. `renderItem`
-    draws each proposal (a `ChangeDiff` before→after body, a record, an editable form), 1-by-1
-    Keep/Drop collapses each (e.g. ingested rate lines — `tpl_ratedesk`); whole-set mode reviews the
-    lot. It is the LIST only — the commit bar (Accept all / Apply / Discard) is the SEPARATE
-    **`ChangeReviewActions`**, which the host places where commit bars belong (a `DialogFooter` /
-    `DrawerFooter`, or inline under the list). Don't bundle a commit into a scroll body — like every
-    other footer in the kit it's the container's to pin (`tpl_ratedesk` puts it in the `DialogFooter`).
-    `ChangeReviewActions` reads the same `items`/`statusOf`, so it owns Accept-all + the kept count —
-    never re-derive them in the host.
-  The body atoms (`RecordFields`, `MatchSides`, `ChangeDiff`) are pure presentation — usable inside
-  either engine OR standalone (a live-edit field card). The decide / accept-all / apply mechanics are
-  never re-implemented per surface.
+- **Review before apply — ONE surface, the compound `ChangeReview` family.** Every "the agent
+  proposes → the human accepts / edits / dismisses → nothing auto-applies" surface composes from
+  twelve pieces in three groups. **Frame**: `ChangeReview` (context provider + stack; hairline
+  dividers between `Change` sections — and `ChangeFields` rules between fields) ·
+  `ChangeReviewHeader` (the SECTION heading — md semibold; keep it lean: never repeat the record
+  the dialog is already about) · `ChangeReviewActions` (the commit bar — pin it in the
+  `DialogFooter`/`DrawerFooter`; **Keep all** bottom-left presses every pending decision — pass
+  `onAcceptAll` when field state lives in the host; the "N of M kept" counter reads HERE beside it,
+  never in the header; Apply disables at 0 kept or via `applyDisabled`). **Sections**: `Change`
+  (heading + free body + optional verbs + collapse — omit both callbacks for display-only) ·
+  `ChangeLabel` · `ChangeSummary` (the collapsed row's content) · `ChangeReasoning` (the agent's
+  quiet hairline aside — only when not self-explanatory). **The grammar**:
+  - **`ChangeFields` + `ChangeField`** — THE field unit. `ChangeFields` is the OPEN form (the
+    section IS the record — an extract dialog's one order: no card chrome). Each `ChangeField`:
+    label (sm, muted — the DetailRow convention) · the `−` band when replacing (`before`) · the value — `ChangeValueInput`
+    by default (the green `+` band; pressing it edits IN THE BAND — a borderless input with
+    identical type metrics, so nothing shifts; `unit="pcs"` fixes the suffix outside the editable
+    core — type the number, never the unit) or any input · conflict `candidates` as full-width decision rows + the localized
+    "Type another value" third option (`custom*` props; the outcome band is read-only via
+    `valueReadOnly` — the decision comes from picking, never from editing the band; gate with
+    `keepDisabled`) · row `reasoning` LAST · per-field **Keep/Drop** bottom-right
+    (`status`/`onKeep`/`onDrop`/`onUndo`). A pure REMOVAL is `before` with an empty value — the
+    `−` band alone. A decided field collapses to the compact one-row card (mark · label →
+    `summary` · Undo).
+  - **`ChangeRecord`** — THE item card for SETS of records (order lines): `id` (it registers in
+    the review context like a `Change`), `tone` add/edit/remove, the tinted header band with the
+    localized op word (Add/Edit/Delete · Thêm/Sửa/Xóa) + title, body = its `ChangeField`s, and
+    **the verb level follows the decision level**: add/remove carry ONE card Keep/Drop (fields
+    none — editable parts, one write); edit carries NO card verbs (only its changed fields, each
+    deciding for itself — dropping a field narrows the update diff). Collapses via `summary`.
+  - **`ChangeBand`** — the raw diff band (aligned `+`/`−` marker column, light emerald/red, dark
+    text) every piece builds from; reach for it directly for custom strokes.
+  **The scaling boundary (known, deliberate)**: `ChangeFields` + `ChangeRecord` cards cover one
+  record through ~10; a BULK review (30+ imported rows — a bank statement, an Excel import) needs a
+  dense form that does not exist yet — design it against the first real migration, not
+  speculatively.
+  **The laws**: ONE verb pair everywhere — Keep/Drop, localized; never rename per shape (Apply is
+  the only outcome-named button). Candidate rows carry the VALUE only; provenance = `Sources` at
+  the VERY bottom of the review (after every change; or omit it — lean beats decorated). The HOST owns every decision in plain `useState`; the family owns the
+  mechanics (collapse + Undo, the counter, Keep-all, apply gating). Never apply a field with no
+  value — gate unresolved conflicts. Editing IS the review.
 - **Ask back** — `Clarify`: when the agent is unsure, it asks a question with quick-reply options
   and PAUSES, instead of guessing wrong. Human-in-the-loop input mid-run.
 - **Provenance** — `Sources`: openable chips saying where the output came FROM (records, a
@@ -476,54 +520,43 @@ a conversation, a single pass, or generated prose:
 - **Canvas** (`tpl_dieline`) — the page IS the design on a pannable/zoomable surface: it stays
   CENTRED at every zoom (a floating zoom pill bottom-left), the FLOATING composer at the bottom (a
   `Composer`: attach a photo → review/remove it → add a note → send, with `sendDisabled` allowing a
-  file-and/or-text submit — NOT auto-run on attach) morphs into `AgentProgress` while running, and a pinned PARAMS PANEL (a `RecordFields` field-card
+  file-and/or-text submit — NOT auto-run on attach) morphs into `AgentProgress` while running, and a pinned PARAMS PANEL (a label/value field-card
   in live-edit mode, carrying the single Download; minimizes to a pill) floats centre-right. Panel, zoom pill and composer
   float ON TOP — they never shift the design. (Floating layers use a `pointerEvents:"none"` wrapper
   with the interactive child set `"auto"`; RN-Web ignores `"box-none"` in style, so a full-width
   wrapper would otherwise eat clicks on the canvas behind it.) Change the design by prompt ("5 mm
   taller") OR by editing a param directly — either re-flows it in place. For a design/document the
   user shapes over time.
-- **Chat** (`tpl_assistant`) — a conversation where the agent's answer carries suggested edits the
-  user approves/rejects **1-by-1** (`ChangeReview` per-item), applying only the accepted set. An AI
-  copilot that proposes changes to a record and never commits on its own.
-- **One-shot** (`tpl_extract`) — read an image → the agent extracts the records → review each as a
-  `ReviewCard` wrapping a `RecordFields` body (fields click-to-edit, Confirm collapses it to a
-  checklist row) → Save all to the table. A data-capture pass; nothing stored until confirmed.
-- **Bulk ingest desk** (`tpl_ratedesk`) — the page IS a filterable register (a From → To route picker
-  + `ColumnFilter` pills → `Card padding:0` + full-bleed `Table`), the register the hero. Updating
-  prices is ONE header CTA that opens a Dialog wizard: drop SEVERAL source docs at once → the agent
-  reads them all (`AgentRun`) → a `ChangeReview` 1-by-1 (each proposal a Keep/Drop card, New / Updated
-  with old→new delta, "Accept all" + Apply) → the kept rows land in the register. Pairs `tpl_extract`'s
-  ingest with `tpl_directory`'s register. For a maintained reference table — rate card, price list,
-  tariff, catalogue: re-ingest the source sheets beats hand-typing.
-- **Draft** (`tpl_draft`) — the agent writes a first draft from context; the OUTPUT itself streams
-  (the text fills in live), then becomes an editable surface the human refines before sending.
-  Tone/length steer it. For generated prose — a reply, a quote, a listing.
+
 
 The next six output STRUCTURE the first four can't — when the answer is a panel of facts, a queue of
 decisions, or a ranked set, don't cram it into chat prose. Each pairs a template with a primitive:
-- **Answer desk** (`tpl_lookup`, `SpecList`) — describe the goods on the LEFT → the agent RANKS the
+- **Answer desk** (`tpl_lookup`) — describe the goods on the LEFT → the agent RANKS the
   matching codes (NEAREST MATCHES, the top one Recommended) → pick one and its STRUCTURED answer pins on
   the RIGHT (a verdict header + an exact breakdown + the policies + sources). Input → matches → pick,
   NOT a single confident verdict: classification is ambiguous, so the alternatives are first-class and
   picking a different one changes the duty; refining the description re-ranks. For look-up-and-explain:
   tariff/HS, fee lookup, policy Q&A, a spec/compliance desk. (NOT a chat with the answer in a bubble.)
-- **Match** (`tpl_match`, body-first `ReviewCard` + `MatchSides`) — the agent proposes PAIRINGS with
-  its reasoning; each is a `ReviewCard` (no title, so body-first) whose body is a two-sided `MatchSides`
-  pairing (source → proposed counterpart), with the confidence + reason beneath, accept / reassign /
-  reject, high-confidence batch-accept. The AI reconciliation / dedup / correlation queue. (Strip the agent's
-  reasoning and it would be a plain deterministic match register — the reasoning is the tell for when
-  you need this.)
-- **Briefing** (`tpl_briefing`, `Finding`) — a generated narrative over the data + a RANKED list of
-  what needs attention, each finding carrying a severity, a metric, its sources, and one action. The
-  leadership digest / anomaly scan — the agent's COMMENTARY, not a raw dashboard.
-- **Cross-check** (`tpl_crosscheck`, `Discrepancy`) — the agent compares the documents of one
-  transaction and surfaces every field that DISAGREES; resolve each to a source of truth or flag it.
-  The audit / 3-way-match desk. Symmetric (N sources), unlike a before→after edit.
-- **Triage** (`tpl_triage`, `TriageRow`) — an inbox the agent classified + routed; accept the call,
-  override, or dismiss, high-confidence in bulk. Leads, tickets, documents, emails.
-- **Compare** (`tpl_compare`, `ScoredOption`) — the agent SCORES and ranks options with its rationale
-  and the key specs; the human picks one. Quotes, carriers, suppliers, plans.
+
+- **Document desk** (`tpl_documents` — THE go-to for document-driven records) — the record's files
+  block feeds ONE "Use AI" entry that FORKS into the two document tasks, each a specialized run with
+  a task-pure result: **Extract** (files read → fields already matching fold into one quiet line →
+  every add / update / conflict a `ChangeField` (struck before · bordered input · candidate chips),
+  the record's current value a first-class choice — plus proposed new lines as record-body `Change`s
+  → one outcome-named `ChangeReviewActions` commit) and
+  **Cross-check** (documents compared against the record and each other → ranked `Finding`s —
+  severity · title · the prominent metric · sources — separated by hairlines; the findings ARE
+  the outcome the human acts on — no phantom "record verdict" write, a persisted check-status
+  goes stale on the next edit). The fork carries an OPTIONAL instructions field — the user steers what the agent
+  checks or extracts, so `Finding` serves ANY file-based AI request, not just the stock
+  cross-check. Every file list in the flow opens the full-page `FileGalleryModal`. Plus **Create documents**: a readiness checklist (unchecked by
+  default, missing inputs called out) → generate → the files land back on the record. Never merge the
+  two AI tasks into one mixed output — the fork is the design.
+- **Triage** — an inbox the agent classified + routed is a `ChangeReview` of `Change`s (body: the
+  item + the agent's call; verbs Accept / Dismiss; Accept-all covers the high-confidence sweep).
+- **Compare / ranked pick** — one `ChangeField` whose `candidates` carry the ranked options
+  (`description` = the score/reason, `source` where it came from); the human picks one. Quotes,
+  carriers, suppliers, plans.
 
 The AI vocabulary has **no purple accent and no gimmick glyphs** (no sparkles) — but it is NOT
 monochrome: **colour is used where it carries meaning, not for decoration.** What the violet sparkle
@@ -533,17 +566,16 @@ a left-ruled margin note (a hairline rule + muted text), quoted apart from the f
 controls — while **status/severity/diffs use functional colour** the way the rest of the kit does:
 - **Confidence** — a 3-tick meter + the full phrase ("High confidence" / "Medium" / "Low"), emerald /
   amber / zinc by level; `labels` to translate (one phrase per level).
-- **Finding severity** — a coloured dot `Badge` + metric: red critical, amber warning, blue note,
-  emerald on-track (+ stacking order, most severe first). The badge words localize through
-  `LoticsLocaleProvider` (`locale.finding`, override per-instance via `labels`) — never hardcode them.
 - **Stepper / AgentRun nodes** — progress dots on a spine: `current` a **pulsing accent ring** (white
   centre), `done` a filled accent dot + **white check**, `upcoming` a faint **grey** ring, the terminal
   `complete` a **blackish ring + black check**, `warning` **amber**. Default accent is neutral ink
   (`color` themes it); `AgentRun` keeps the neutral default — an active group's tail pulses (`current`),
   a settled group is a `done`/`warning` row, and there is no global terminal node (the run ends on text).
-- **ChangeReview diffs** — the old value struck in **red**, the new value in **green**.
-- **Discrepancy** — the agent's pick gets a **blue** highlight; `Mismatch` reads amber, `Resolved`
-  emerald.
+- **ChangeBand** — the removed value on the light **red** band with the `−` marker, the incoming
+  value on the light **emerald** band with `+` (the GitHub-diff idiom, markers in one aligned
+  column); everything else in a review stays neutral — a decided row reads a single emerald check,
+  an add/remove record card wears the quiet tone wash (50 body · 100 header · 200 border). Colour
+  marks the change, never the chrome.
 
 Card chrome (borders, microlabels) stays neutral — colour marks the *state*, never the container.
 The **composer keeps its icons**: `Composer` compact is a single-row pill with an optional circular
@@ -726,7 +758,9 @@ was only ever about the review surfaces' sparkles/severity glyphs, not functiona
   `Drawer` (above). (2) **Act on many** — a flat list with a leading `CheckboxInput` per row + a
   select-all `CardHeader` band, plus a bottom-pinned `<FloatingActionBar count label onClear>`
   carrying the bulk action(s) while ≥1 row is ticked (`tpl_item_list`); a row
-  that can't take the action has NO checkbox. When a region genuinely must sit beside the list (a
+  that can't take the action has NO checkbox. Bar weight gradient, left → right: the built-in
+  Clear is muted (the quietest act), destructive bulk = `danger-secondary` + icon, secondary
+  bulk = `secondary` + icon, ONE primary CTA last — never repeat the count in a CTA title; the bar's label already carries it. When a region genuinely must sit beside the list (a
   source/remainder summary, a capacity picker) make it a TOP summary header or move it into a
   Popover/sheet at the decision point — not a standing column.
 - **One control radius** — every interactive control (`Button`, the inputs/selects/pickers,
@@ -863,17 +897,12 @@ recipe for a screen JOB; copy and adapt). Pick by the job:
 - **AI workflows** — *produce*: `tpl_dieline` (the design CANVAS: photo → stream → the dieline
   reveals CENTRED on a pannable/zoomable surface, the floating composer morphing into `AgentProgress`,
   a pinned live-edit params panel centre-right; prompt OR edit a param to iterate) ·
-  `tpl_assistant` (a chat copilot: the agent's answer carries suggested edits approved/rejected
-  1-by-1) · `tpl_extract` (read an image → extract records → review/edit each (`ReviewCard` +
-  `RecordFields`) → Save all) · `tpl_ratedesk` (BULK INGEST desk: a register-as-hero with an "Import
-  prices" CTA → a Dialog wizard: drop several sheets → `ChangeReview` 1-by-1 → kept rows land in the
-  register; for a maintained rate card / price list / tariff) · `tpl_draft` (draft generation: context → the reply text streams into an editable surface
-  → refine → send; tone/length steer it). *Structure*: `tpl_lookup` (the ANSWER desk: converse left,
-  a pinned `SpecList` verdict panel right; a follow-up refines it) · `tpl_match` (AI reconciliation:
-  body-first `ReviewCard` + `MatchSides` pairings with reasoning, accept/reassign/reject) · `tpl_briefing` (a generated narrative
-  + a ranked `Finding` attention list) · `tpl_crosscheck` (the audit desk: `Discrepancy` cards where
-  the documents disagree) · `tpl_triage` (an inbox of `TriageRow`s the agent classified + routed) ·
-  `tpl_compare` (ranked `ScoredOption` candidates the agent scored).
+  *Structure*: `tpl_lookup` (the ANSWER desk: converse left,
+  a pinned verdict panel right; a follow-up refines it) ·
+  `tpl_documents` (the DOCUMENT DESK — files on a record → the Use-AI fork: extract = the open
+  `ChangeFields` review (adds/updates/removal/conflict) + proposed order lines as `ChangeRecord`
+  cards, Keep-all + one outcome-named Apply; cross-check = display-only `Change` findings → a
+  recorded verdict; plus the Create-documents readiness checklist).
 
 ---
 
@@ -910,14 +939,21 @@ file_gallery_modal · image_gallery · use_selection (useSelection — always-on
 spacer · stack · section_card · page_header · page_content · calendar (calendar/index.ts) · gantt ·
 comments_thread · agent_run (live streaming work feed) · agent_progress (its compact floating
 expandable form — a composer's working state) · composer (Composer — the adaptive command/chat
-composer: a compact pill that expands for long text + attachments) · review_card (ReviewCard — THE single-proposal review card; compositional body via children + a generic actions footer; header-first with a title/eyebrow, body-first without) · confidence (calibrated high/med/low) ·
-record_fields (RecordFields — the editable extracted-record BODY for a ReviewCard, or a standalone live-edit field card) · change_review (ChangeReview — the BATCH review LIST, whole-set OR 1-by-1; compositional `renderItem` body + the `ChangeDiff` before→after helper, `labels` localizes Undo/Applied/Discarded/counter — PLUS `ChangeReviewActions`, the separate commit bar the host pins in a `DialogFooter`/`DrawerFooter` or inline so it never scrolls away) ·
+composer: a compact pill that expands for long text + attachments) · confidence (calibrated high/med/low) ·
+change_review (the COMPOUND review family — frame: ChangeReview provider/stack · ChangeReviewHeader
+(auto kept-counter over decidable entries) · ChangeReviewActions (the commit bar in the
+DialogFooter/DrawerFooter: Keep-all bottom-left (onAcceptAll for host-held field state) + Apply
+gating); sections: Change (host-owned status, labeled verbs, collapses to its ChangeSummary + Undo;
+no callbacks = display-only) · ChangeLabel · ChangeSummary · ChangeReasoning (the quiet why);
+grammar: ChangeFields (the open record form) + ChangeField (THE field: − band · value · candidates
++ type-another-value · reasoning · per-field Keep/Drop · collapse) · ChangeRecord (THE item card:
+registers like a Change; tone wash + localized op word; verb level follows the decision level) ·
+ChangeBand (the raw ± band) · ChangeValueInput (the diff-at-rest editor); the `changeReview`
+locale slice) ·
 clarify (the agent asks back, via ChoiceList) · choice_list (ChoiceList — selectable answer options,
-the agent's quick-reply surface) · sources (provenance chips, per-kind glyphs) · spec_list (SpecList — the exact
-labeled-value breakdown, the panel of an answer) · match_sides (MatchSides — the two-sided pairing BODY for a body-first ReviewCard reconciliation; composable side slots + the MatchSideText default) ·
-finding (Finding — one ranked briefing/audit insight) · discrepancy (Discrepancy — a field that
-disagrees across sources) · triage_row (TriageRow — an item the agent classified + routed) ·
-scored_option (ScoredOption — an AI-ranked candidate) ·
+the agent's quick-reply surface) · sources (provenance chips, per-kind glyphs) · finding (Finding — one ranked AI-check insight: severity word · title · detail · Sources ·
+children slot — with FindingComparison, the expected-vs-actual body: labeled sides + emphasized
+delta; the `finding` locale slice) ·
 format_money · format_date · colors (solid · tint · ramp · ColorName ·
 isColorName · asColorName — coerce a stored option/status token to a ColorName, neutral fallback) ·
 use_focus_ring (useFocusRing — keyboard-aware focus state for painting a control's own ring; see Focus rings) ·

package/examples/tpl_dieline.tsx

@@ -24,8 +24,8 @@ const MOCK_PHOTO: DisplayFile = {
 // ─────────────────────────────────────────────────────────────────────────────
 // Template · AI design canvas (the carton "dieline" app) — the FLAGSHIP shape:
 // the page IS the design. The dieline fills the centre, a FLOATING composer sits
-// at the bottom, and a pinned PARAMS PANEL (a RecordFields field-card, here in
-// live-edit mode) floats at the centre-right. Empty → drop a photo in the
+// at the bottom, and a pinned PARAMS PANEL (a hand-composed label/value field-card
+// in live-edit mode) floats at the centre-right. Empty → drop a photo in the
 // composer → the centre processes while the composer MORPHS into a progress pill
 // (AgentProgress) → the dieline reveals, the params panel appears, the composer
 // returns. Two ways to change it: prompt the agent ("5 mm taller"), or edit a
@@ -229,7 +229,7 @@ export function TplDieline() {
   );
 }
 
-// The pinned right-rail — a RecordFields field-card in live-edit mode: each
+// The pinned right-rail — a label/value field-card in live-edit mode: each
 // parameter is click-to-edit and re-flows the design on save; one primary
 // Download. Floats over the canvas, so it carries the composer's lift.
 const PARAMS: { key: keyof Dims; label: string }[] = [