Story: Consolidate history dialogs onto HistoryDialogBase

Every entity history dialog derives from HistoryDialogBase and shares one implementation of the common machinery, so that fixes and UX changes land once instead of 67 times, and the per-dialog code shrinks to what is genuinely entity-specific (field comparisons and labels).

Survey (2026-06-05, the day the CI broke on exactly this duplication):

• 67 *HistoryDialog classes across ores.qt sub-libraries.
• HistoryDialogBase already exists in ores.qt.api (signals, markAsStale(), code()) but has exactly one adopter (WorkspaceHistoryDialog).
• 64 dialogs duplicate the version-list/load pipeline (onVersionSelected, loadHistory, QFutureWatcher plumbing).
• 6 dialogs (Account, SystemSetting, ChangeReason, ChangeReasonCategory, Country, Currency) hand-roll a changes tab with field-level diffs using four different idioms: a free function, per-call lambdas, a CHECK_DIFF_STRING macro, and inline if-blocks. The Account variant named a class-private alias from an anonymous-namespace function, breaking GCC/AppleClang builds (fixed tactically; this story is the proper fix).

Design direction — two layers:

1. Server-side diffs (the deeper fix). Computing field-level diffs in the UI is the wrong place: when history views are added to the shell, Wt and HTTP frontends the same comparison code would be repeated in each. Instead:
   • A per-entity mapper converts a domain type to an ordered list of (field name, value) strings — one definition per entity, server side, reusable by every frontend and candidate for codegen from the entity models.
   • A generic NATS history message returns the computed diffs between consecutive versions (field, old value, new value), rather than shipping two full versions for the client to compare. Frontends only render.
2. Qt consolidation onto the base.
   • DiffResult (list of (field, (old, new)) rows) is defined once in HistoryDialogBase.
   • The base owns the changes-tab rendering flow and calls an abstract calculateDiff(current, previous) template method; derived dialogs implement only the per-entity field comparisons. Once the server-side diff message lands, calculateDiff implementations collapse into rendering the server-provided rows, and the template method may disappear entirely.
   • Shared checkString / checkInt / checkBool helpers live with the base so all dialogs format values identically in the interim.
   • Version-list population, async load, stale handling and toolbar wiring migrate into the base (or an intermediate templated CRTP helper if the version types resist a common interface).

Full architecture lives in History Diff Architecture (written by the redesign task, superseding this section's original three-layer sketch and the reverted currency pilot it described). Summary:

• One generic NATS history request (history.v1.get, entity type + entity id), dispatched server side to a codegen'd per-entity handler via a runtime lookup table — reapplying the existing Entity-composed registrars meta-pattern rather than a typed per-entity subject. No typed domain payload crosses the wire for history.
• A codegen'd, plain (not hand-written, not generic-reflection) per- entity field-to-string mapper, plus a generated entity_type_of() trait as the single source of truth for the dispatch key.
• ores.diff (unchanged as a dedicated leaf component) extended with intra-value diff spans, computed once, entity-agnostic by construction.
• One concrete, non-templated HistoryDialog Qt widget and one shell renderer, shared by every entity — no per-entity Qt classes, no HistoryDialogBase subclassing. Open=/=Revert carry only (entity_type, entity_id, version), dispatched client side through a small codegen'd per-entity action registry (same meta-pattern, client side) that opens the entity's own typed detail dialog.
• Composite/referenced-entity delegation needs no special-casing: opening another entity's history is just constructing the same dialog with a different entity id.

Migration still runs codegen-free phases before the template rollout, per the original gating principle: the org-model migration gate is clear, but the redesigned mapper/dispatch/HistoryDialog above must land before the ~61-dialog rollout proceeds, since it changes what that rollout produces.

Closed at Sprint 23's end, narrowed to what shipped: the entire new server-side diff architecture and the single generic HistoryDialog widget. The remaining Phase C cleanup task (deleting HistoryDialogBase and the last per-entity dialogs, blocked on every other ores.qt component migrating first) split into a Sprint 24 story — see Retire per-entity history dialogs: Phase C rollout.

• [X] Field-level diffs are computed server-side; no frontend holds comparison logic.
• [X] ores.diff exists with exhaustive engine tests; mappers and handlers are tested at their own layers.
• [X] The shell can render history as a unified diff.
• [X] A single generic HistoryDialog widget replaces the HistoryDialogBase/per-entity-subclass design; ores.qt.refdata fully migrated onto it.
• [X] No codegen change was forced while the org-model migration was in flight; the template rollout was explicitly gated.

• Closed at Sprint 23's end with acceptance narrowed to what shipped, rather than left open indefinitely. The single remaining task (retire the last per-entity dialogs) genuinely is the bulk of what's left workwise, but it can't proceed until every other ores.qt component migrates first, so it moved to its own Sprint 24 story rather than keeping this one open with no other active work.
• A dedicated ores.diff component (not a corner of ores.utility): the types cross every domain service and every frontend; a leaf component keeps the dependency arrows clean and matches the many-small-components style. Stands.
• Responses carry both fields and changes — mildly redundant, but it makes every frontend a dumb renderer, which is the point. Stands; changes now also carries intra-value diff spans.
• Superseded 2026-07-11: "keep the typed per-entity history subjects" is replaced by one generic history subject (history.v1.get), dispatched server side to a codegen'd per-entity handler via a runtime lookup table — see History Diff Architecture. The per-entity mapper is codegen'd from the outset (plain, generated code — not hand-written, and not a generic rfl-reflection framework), so "codegen'd mappers deferred outright" is also superseded: it is folded into the redesign rather than deferred to a separate Phase D.
• HistoryDialogBase (base class + per-entity derived dialogs) is replaced by a single, non-templated HistoryDialog widget shared by every entity; Open=/=Revert carry only (entity_type, entity_id, version), dispatched through a small codegen'd per-entity action registry rather than a typed signal payload. No per-entity Qt class survives the rollout.
• Composite/referenced-entity history needs no special-casing: delegating to another entity's history is constructing the same HistoryDialog with a different entity id.
• entity_type_of() lives in the existing domain class header (cpp_domain_type_class.hpp.mustache), not a new companion file or archetype — a separate companion header was built and validated first, then retired: no need for more generated files when the function fits in the entity's existing header. Generation is scoped to ores.refdata for now (the component this story touches), and within it, to entities whose regeneration surfaced no pre-existing drift — see the task's Notes for the affected entities (including party), deferred as a known gap.
• The history field mapper's per-column type dispatch (new render_is_* flags) is derived from each column's raw cpp_type string — the same ground truth the domain class template itself emits verbatim — never from the repository/SQL layer's is_uuid=/=is_nullable_string=/=is_already_optional flags, which encode a nullable-to-optional promotion the domain class template does not apply. A first implementation attempt used the wrong flags and failed to compile against real entities; see the history-field-mapper task's Notes for the full story.
• The Gemini-review redesign (task 1EAE3E54) lands on currency only; the other 60+ entities still use the pre-redesign HistoryDialog layout until they migrate onto compare mode, tracked by the sibling Migrate ores.qt.refdata onto the generic HistoryDialog story (now scoped to refdata; other ores.qt components are their own backlog captures). Provenance field names (Modified By, Performed By, Change Reason Code, Change Commentary, Recorded At) are centralized as ores::history::domain::provenance_fields in ores.history.api, shared by the field mappers and any presentation layer that renders them separately from an entity's own diffable fields (e.g. the redesigned timeline cards).
• ores.history's messaging/service layer (dispatch_registry, history_handler, registrar) depends on ores.database=/ =ores.security directly — it is server-only NATS glue no client ever touches, and every service that registers a history_provider already links both to do anything else. An earlier attempt to keep the whole component a dependency-free leaf (modeled on ores.diff's client-visible field_value=/=diff_result) forced an opaque caller_context string and, when that dropped party/roles/ workspace scope, a JSON pack/unpack workaround — both since deleted. history_provider takes a real database::context; history_handler calls make_request_context() itself like every other handler. Only history_protocol.hpp (wire types) and version_builder.hpp stay a true leaf, since those genuinely are client-visible. See the generic-history-subject task's Notes for the full reasoning.