@startsimpli/ui 0.4.139 → 0.4.141

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startsimpli/ui",
-  "version": "0.4.139",
+  "version": "0.4.141",
   "description": "Shared UI components package for StartSimpli applications",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -49,9 +49,9 @@
     "next": "^14.0.0 || ^15.0.0 || ^16.0.0",
     "react": "^18.0.0 || ^19.0.0",
     "react-dom": "^18.0.0 || ^19.0.0",
-    "@startsimpli/api": "^0.5.66",
+    "@startsimpli/i18n": "^0.1.3",
     "@startsimpli/auth": "^0.4.38",
-    "@startsimpli/i18n": "^0.1.3"
+    "@startsimpli/api": "^0.5.66"
   },
   "peerDependenciesMeta": {
     "@startsimpli/api": {
@@ -126,8 +126,8 @@
     "tailwindcss": "^3.4.19",
     "tsup": "^8.5.1",
     "typescript": "^6.0.3",
-    "@startsimpli/realtime": "0.0.2",
-    "@startsimpli/i18n": "0.1.3"
+    "@startsimpli/i18n": "0.1.3",
+    "@startsimpli/realtime": "0.0.2"
   },
   "keywords": [
     "ui",

package/src/components/ActivityTimeline.tsx

@@ -197,24 +197,29 @@ function TimelineEntry({
             {activity.description && (
               <p className="mt-1 text-sm text-muted-foreground">{activity.description}</p>
             )}
-            {activity.detail && (
-              // A DIV, NOT A P. `detail` is typed ReactNode and the record
-              // history panel passes a field LIST into it — and a <ul> or a
-              // <div> inside a <p> is invalid HTML, which React resolves by
-              // reparenting during hydration. That produces a hydration
-              // mismatch on every row, and neither tsc nor jsdom reports it:
-              // only a real browser does (bd startsim-g4rwo). The classes are
-              // unchanged, so every existing caller renders identically.
-              <div className={`mt-1 break-words text-xs ${TONE_TEXT[activity.detailTone ?? 'muted']}`}>
-                {activity.detail}
-              </div>
-            )}
           </div>
           <div className="ml-4 whitespace-nowrap text-xs text-muted-foreground">
             {formatTime(activity.occurredAt)}
           </div>
         </div>
 
+        {activity.detail && (
+          // A DIV, NOT A P. `detail` is typed ReactNode and the record history
+          // panel passes a field LIST into it — and a <ul> or a <div> inside a
+          // <p> is invalid HTML, which React resolves by reparenting during
+          // hydration. That produces a hydration mismatch on every row, and
+          // neither tsc nor jsdom reports it: only a real browser does
+          // (bd startsim-g4rwo).
+          //
+          // BELOW the title/timestamp row, not inside its left column: there it
+          // shared the line with the timestamp and lost ~100px of a 366px
+          // review rail to it, which is what left a field's before/after a
+          // column of single characters (bd startsim-jkkn7.12).
+          <div className={`-mt-1 mb-2 break-words text-xs ${TONE_TEXT[activity.detailTone ?? 'muted']}`}>
+            {activity.detail}
+          </div>
+        )}
+
         <div className="flex flex-wrap items-center gap-x-4 gap-y-1 text-sm text-muted-foreground">
           <ActorIdentity
             actor={activity.actor}

package/src/components/ActorIdentity.tsx

@@ -113,8 +113,17 @@ export function actorHandle(actor?: ActorIdentityValue): string {
  *                        panel instead, and only when some loaded row is
  *                        actually unknown.
  *
- * The truth is never *lost* in the quiet cases — it goes into the element's
- * accessible title, so hover and assistive tech still report it.
+ * The truth is never *lost* in the quiet cases. Whenever a kind is passed, the
+ * WRAPPER carries {@link actorKindTitle} as its `title`, on every row and not
+ * only on the marker, so hover and the accessible description report it for an
+ * unknown or claimed-person row too (bd startsim-jkkn7.15). It is a title and
+ * NOT sr-only text on purpose: this chip sits inside sentences
+ * ("<actor> changed this record while you were editing"), and a hidden
+ * sentence spliced into the middle of one reads worse than no sentence.
+ *
+ * `person`/`inferred` is unreachable today — the server's inference ladder
+ * floors at `unknown` and a believed claim always records `claim` — so its
+ * branch below is dead code kept on purpose, as the guard it is.
  */
 function kindMarker(
   kind: ActorKind | undefined,
@@ -185,12 +194,16 @@ export function ActorIdentity({
   if (!label && !marker) return null;
   const initials = showInitials && label ? actorInitials(actor) : '';
   const handle = actorHandle(actor);
+  const kindTitle = kind ? actorKindTitle(kind, kindSource) : undefined;
 
   return (
     <span
       data-testid="actor-identity"
       data-actor-kind={kind ?? undefined}
       data-actor-kind-source={kindSource ?? undefined}
+      // Only when a kind was passed: every surface that predates the actor axis
+      // must render exactly as it did (see the `kind` prop).
+      title={kindTitle}
       className={className}
     >
       {initials && <span className={initialsClassName}>{initials}</span>}

package/src/components/charts/TimeSeriesChart.tsx

@@ -53,25 +53,32 @@ export interface TimeSeriesChartProps {
 /**
  * Series colours, in order, from the theme contract (theme/contract.css) — so
  * they follow the app's brand and flip with `.dark` like every other surface.
- * `--success` carries the same fallback channels as the Tailwind preset, for
- * apps that predate the token.
+ *
+ * Categorical only: a series' colour says which series it is, nothing more.
+ * `--success` and `--destructive` are deliberately absent — they mean good/bad
+ * (gain/loss), and a series that happened to land on one would assert that.
+ * `--secondary` and `--accent` are surface tones, too faint to read as a
+ * stroke. That leaves three tokens, so distinguishability comes mostly from
+ * the dash cycle below.
  */
 export const SERIES_COLORS = [
   'hsl(var(--primary))',
   'hsl(var(--muted-foreground))',
-  'hsl(var(--success, 142.1 76.2% 36.3%))',
-  'hsl(var(--destructive))',
   'hsl(var(--foreground))',
 ] as const
 
-/** After the palette runs out, series repeat its colours with a dash. */
-const DASHES = [undefined, '6 4', '2 3'] as const
+/**
+ * Each pass through the palette gets the next dash: solid, dashed, dotted,
+ * dash-dot. 3 colours x 4 dashes = 12 series before a style repeats. The
+ * patterns fit the 16px legend swatch so each one shows its full rhythm.
+ */
+export const SERIES_DASHES = [undefined, '6 4', '2 3', '8 3 2 3'] as const
 
 export function seriesStroke(index: number): { color: string; dash: string | undefined } {
   const n = SERIES_COLORS.length
   return {
     color: SERIES_COLORS[index % n],
-    dash: DASHES[Math.floor(index / n) % DASHES.length],
+    dash: SERIES_DASHES[Math.floor(index / n) % SERIES_DASHES.length],
   }
 }
 

package/src/components/charts/__tests__/TimeSeriesChart.test.tsx

@@ -1,5 +1,5 @@
 import { render, screen } from '@testing-library/react'
-import { TimeSeriesChart, SERIES_COLORS, seriesStroke } from '../TimeSeriesChart'
+import { TimeSeriesChart, SERIES_COLORS, SERIES_DASHES, seriesStroke } from '../TimeSeriesChart'
 import type { TimeSeries } from '../lib/series'
 
 // jsdom lays nothing out: recharts' ResponsiveContainer renders no chart at a
@@ -74,6 +74,19 @@ describe('TimeSeriesChart', () => {
     expect(new Set(strokes)).toEqual(new Set([SERIES_COLORS[0], SERIES_COLORS[1]]))
   })
 
+  it('dashes the series that repeat a colour, on the line and in the legend', () => {
+    const four = [0, 1, 2, 3].map((k) => ({ ...holding, name: `S${k}` }))
+    const { container } = render(<TimeSeriesChart series={four} unit="$" />)
+    const lines = linePaths(container)
+    expect(lines).toHaveLength(4)
+    expect(lines[3].getAttribute('stroke')).toBe(lines[0].getAttribute('stroke'))
+    expect(lines[3].getAttribute('stroke-dasharray')).toBe('6 4')
+    expect(lines[0].getAttribute('stroke-dasharray')).toBeNull()
+
+    const swatches = Array.from(container.querySelectorAll('ul svg line'))
+    expect(swatches.map((l) => l.getAttribute('stroke-dasharray'))).toEqual([null, null, null, '6 4'])
+  })
+
   it('shows a legend for two or more series and none for one', () => {
     const { rerender } = render(<TimeSeriesChart series={[strategy, holding]} unit="$" />)
     expect(screen.getByText('Strategy')).toBeInTheDocument()
@@ -132,10 +145,42 @@ describe('TimeSeriesChart', () => {
 })
 
 describe('seriesStroke', () => {
-  it('cycles the token palette and dashes the repeats', () => {
+  it('uses only non-semantic tokens, in order', () => {
+    expect([...SERIES_COLORS]).toEqual([
+      'hsl(var(--primary))',
+      'hsl(var(--muted-foreground))',
+      'hsl(var(--foreground))',
+    ])
+  })
+
+  it('never colours a series as gain or loss', () => {
+    // --success / --destructive mean good / bad; a categorical series must not
+    // inherit that meaning by landing on one.
+    const styles = Array.from({ length: 40 }, (_, i) => seriesStroke(i).color)
+    for (const color of styles) {
+      expect(color).not.toMatch(/--(success|destructive)\b/)
+    }
+  })
+
+  it('cycles the token palette and steps the dash on each pass', () => {
     const n = SERIES_COLORS.length
     expect(seriesStroke(0)).toEqual({ color: SERIES_COLORS[0], dash: undefined })
+    expect(seriesStroke(n - 1)).toEqual({ color: SERIES_COLORS[n - 1], dash: undefined })
     expect(seriesStroke(n)).toEqual({ color: SERIES_COLORS[0], dash: '6 4' })
     expect(seriesStroke(n + 1).color).toBe(SERIES_COLORS[1])
+    expect(seriesStroke(2 * n).dash).toBe('2 3')
+    expect(seriesStroke(3 * n).dash).toBe('8 3 2 3')
+  })
+
+  it('keeps every series distinct until colours x dashes run out', () => {
+    const distinct = SERIES_COLORS.length * SERIES_DASHES.length
+    expect(distinct).toBe(12)
+    const keys = Array.from({ length: distinct }, (_, i) => {
+      const { color, dash } = seriesStroke(i)
+      return `${color}|${dash ?? 'solid'}`
+    })
+    expect(new Set(keys).size).toBe(distinct)
+    // Then the cycle starts over.
+    expect(seriesStroke(distinct)).toEqual(seriesStroke(0))
   })
 })

package/src/components/charts/index.ts

@@ -1,6 +1,6 @@
 // Charts live behind their own subpath (`@startsimpli/ui/charts`) so recharts
 // is only bundled by apps that draw one.
-export { TimeSeriesChart, SERIES_COLORS, seriesStroke } from './TimeSeriesChart'
+export { TimeSeriesChart, SERIES_COLORS, SERIES_DASHES, seriesStroke } from './TimeSeriesChart'
 export type { TimeSeriesChartProps, TimeSeriesReferenceLine } from './TimeSeriesChart'
 export type {
   TimeSeries,

package/src/components/history/RecordHistoryPanel.tsx

@@ -40,14 +40,19 @@
  *    because this route serves every historical value a record ever held, so it
  *    is a richer leak than the row read — and because a `{}` rendered silently
  *    reads as data loss.
- * 3. THAT THE TRAIL IS NOT THE WHOLE STORY. Four write paths record NO revision
- *    today — `annotate`, `move-scope`, `DELETE` and the ingestion worker
- *    (bd startsim-jkkn7.6). The version sequence is still provably gapless
- *    (a write that records nothing allocates no number), so there is no hole to
- *    see — which is exactly why it has to be SAID. A reader must not conclude
- *    from a quiet trail that no machine touched this record. The panel
- *    therefore never claims completeness, and its empty state says "no edits
- *    recorded" and not "never changed".
+ * 3. WHEN HISTORY IS DECLARED OFF FOR THIS KIND OF RECORD. Every write path
+ *    records a revision now — `annotate`, `move-scope`, `DELETE` and the
+ *    ingestion worker were the last four, closed by bd startsim-jkkn7.6 — so the
+ *    old standing caveat that "some writes are not recorded yet" described a gap
+ *    that no longer exists, and was removed (bd startsim-jkkn7.11). What CAN
+ *    still leave a trail empty is a DECLARATION: `EntityTypeDef.config.history
+ *    = {"enabled": false}` on the type (or the reserved `"*"` row). That is a
+ *    decision somebody made, not a silent door, so it gets different words —
+ *    "history is not recorded for this kind of record" — and it is said only
+ *    when the host passes `historyEnabled={false}`. The panel cannot see the
+ *    setting itself: it only holds a revisions client, and the revisions
+ *    envelope does not carry the resolved policy. Otherwise the empty state
+ *    says "no edits recorded" and nothing more — and never "never changed".
  */
 import { ReactNode, useMemo } from 'react';
 import { useInfiniteQuery } from '@tanstack/react-query';
@@ -140,9 +145,19 @@ export interface RecordHistoryPanelProps {
   errorTitle?: string;
   notFoundTitle?: string;
   notFoundMessage?: string;
-  /** The standing caveat that the trail has known silent write paths. Pass
-   *  `null` only if the surrounding page already says it — not to make the
-   *  panel look more complete than it is. */
+  /** Whether this record's TYPE keeps a history, as resolved from
+   *  `EntityTypeDef.config.history` (the type's own declaration, else the
+   *  reserved `"*"` row, else on). `false` makes the panel say that history is
+   *  not recorded for this kind of record, beside any rows written before it
+   *  was switched off. Omitted or `true` says nothing — the panel never
+   *  invents a caveat it cannot back. bd startsim-jkkn7.11. */
+  historyEnabled?: boolean;
+  /** The sentence shown when {@link historyEnabled} is `false`. */
+  declaredOffNote?: ReactNode;
+  /** An extra caveat under the trail, for a host that knows something about
+   *  this record's coverage the panel cannot. None by default: since bd
+   *  startsim-jkkn7.6 every write path records, and a standing "some edits may
+   *  be missing" would teach readers to discount a complete trail. */
   incompleteNote?: ReactNode;
   classNames?: RecordHistoryPanelClassNames;
 }
@@ -166,11 +181,14 @@ export function RecordHistoryPanel({
   notFoundTitle = 'History is not available to you',
   notFoundMessage =
     'This record, or your access to it, has changed. Reopen the record to see its history.',
-  incompleteNote =
-    'Some writes are not recorded yet — bulk imports, scope moves, annotations and deletions leave no entry — so a quiet history is not proof that nothing else touched this record.',
+  historyEnabled,
+  declaredOffNote =
+    'History is not recorded for this kind of record — it has been switched off for this type, so new edits do not appear here.',
+  incompleteNote = null,
   classNames = {},
 }: RecordHistoryPanelProps) {
   const cx = { ...RECORD_HISTORY_PANEL_DEFAULTS, ...classNames };
+  const declaredOff = historyEnabled === false;
 
   const query = useInfiniteQuery<RevisionPage>({
     queryKey: [...queryKey, { pageSize, windowMs }],
@@ -214,6 +232,13 @@ export function RecordHistoryPanel({
     () => sittings.some((s) => s.actorKind === 'unknown'),
     [sittings],
   );
+  // A claimed person is undecorated exactly like an unknown row, so when both
+  // are loaded "the rest" would sweep in the one row whose kind WAS recorded
+  // (bd startsim-jkkn7.15). Each row's own title/sr-only text says which.
+  const anyClaimedPerson = useMemo(
+    () => sittings.some((s) => s.actorKind === 'person' && s.actorKindSource === 'claim'),
+    [sittings],
+  );
 
   // Sentence 2 — the server's own roll-up over this page's rows, unioned
   // across the pages loaded so far.
@@ -245,9 +270,18 @@ export function RecordHistoryPanel({
       {anyUnknownKind && (
         <p className={cx.notice} data-testid="record-history-unknown-kind">
           Entries marked <strong className="font-medium text-foreground">machine</strong> were
-          made by an automation. For the rest, whether a person or a machine made the edit was
-          not recorded — it is not available for edits made before this was switched on, or by
-          anyone who has not signed in since.
+          made by an automation.{' '}
+          {anyClaimedPerson
+            ? 'Some unmarked entries were recorded as made by a person; for the others, whether a person or a machine made the edit was not recorded'
+            : 'For the rest, whether a person or a machine made the edit was not recorded'}{' '}
+          — it is not available for edits made before this was switched on, or by anyone who has
+          not signed in since.{anyClaimedPerson && ' Hover a name to see which.'}
+        </p>
+      )}
+
+      {declaredOff && !query.isError && (
+        <p className={cx.notice} data-testid="record-history-declared-off">
+          {declaredOffNote}
         </p>
       )}
 
@@ -277,7 +311,9 @@ export function RecordHistoryPanel({
             hasMore={!!query.hasNextPage}
             onLoadMore={loadMore}
             emptyTitle={emptyTitle}
-            emptyDescription={emptyDescription}
+            // Declared off: "edits will appear here" would be untrue, and the
+            // notice above already says why the trail is empty.
+            emptyDescription={declaredOff ? '' : emptyDescription}
             activityIcons={DEFAULT_ICONS}
             defaultIcon={Pencil}
             loadMoreLabel={query.isFetchingNextPage ? 'Loading…' : 'Load more'}
@@ -292,7 +328,7 @@ export function RecordHistoryPanel({
         </p>
       )}
 
-      {/* Sentence 3 — always, when there is anything to qualify. */}
+      {/* A host-supplied caveat only; none by default (see sentence 3). */}
       {incompleteNote && !query.isError && (
         <p className={cx.countLine} data-testid="record-history-incomplete">
           {incompleteNote}

package/src/components/history/RevisionFields.tsx

@@ -57,7 +57,7 @@ const CLAMP = 'max-h-40 overflow-y-auto whitespace-pre-wrap break-words';
  *  screen-reader text — never as an empty box that looks like "" was stored. */
 function Side({ label, has, value }: { label: string; has: boolean; value: unknown }) {
   return (
-    <div className="min-w-0 flex-1">
+    <div className="min-w-0">
       <div className="mb-1 text-[10px] font-medium uppercase tracking-wide text-muted-foreground">
         {label}
       </div>
@@ -106,7 +106,7 @@ function FieldBody({ field, change }: { field: string; change: FoldedFieldChange
   }
 
   return (
-    <div className="space-y-2">
+    <div className="@container space-y-2">
       {kind === 'truncated' && (
         <p className="flex items-start gap-2 text-xs text-muted-foreground">
           <Scissors className="mt-px h-3.5 w-3.5 shrink-0" aria-hidden="true" />
@@ -118,7 +118,13 @@ function FieldBody({ field, change }: { field: string; change: FoldedFieldChange
           </span>
         </p>
       )}
-      <div className="flex flex-wrap gap-3 sm:flex-nowrap">
+      {/* SIZED ON THE CONTAINER, NOT THE VIEWPORT (bd startsim-jkkn7.12). This
+          panel is a composer meant to be embedded, and its common home is a
+          ~370px review rail on a wide screen — where a viewport `sm:` forced the
+          sides next to each other and each got a few dozen pixels. Stacked by
+          default; side by side only once the field body itself is 24rem wide.
+          A grid, not `flex-1` + wrap: a zero flex-basis never wraps. */}
+      <div className="grid gap-3 @sm:grid-cols-2">
         <Side label="Before" has={change.hasBefore} value={change.before} />
         <Side label="After" has={change.hasAfter} value={change.after} />
       </div>

package/src/components/history/__tests__/record-history-panel.test.tsx

@@ -217,19 +217,83 @@ describe('RecordHistoryPanel — attempts, truncation and completeness', () => {
     ).toBeInTheDocument()
   })
 
-  it('NEVER claims the trail is complete', async () => {
-    mount(<RecordHistoryPanel client={clientFor(page([rev({ version: 1 })]))} />)
-    const note = await screen.findByTestId('record-history-incomplete')
-    expect(note).toHaveTextContent(/not recorded yet/i)
-  })
-
   it('an empty history says "no edits recorded", not "never changed"', async () => {
     mount(<RecordHistoryPanel client={clientFor(page([]))} />)
     expect(await screen.findByText('No edits recorded for this record')).toBeInTheDocument()
     expect(screen.queryByText(/never been changed|never changed/i)).not.toBeInTheDocument()
-    // The caveat still stands on an empty panel — a quiet trail is the exact
-    // case a reader would otherwise over-read.
-    expect(screen.getByTestId('record-history-incomplete')).toBeInTheDocument()
+  })
+})
+
+describe('RecordHistoryPanel — what the trail does and does not cover (bd startsim-jkkn7.11/.12)', () => {
+  // bd startsim-jkkn7.6 closed all four silent write paths (annotate,
+  // move-scope, DELETE, the ingestion worker). A caveat that the trail misses
+  // them now describes a gap that does not exist, and teaches a reader to
+  // discount the one surface whose job is to be trusted.
+  it('no longer claims bulk imports, scope moves, annotations or deletions go unrecorded', async () => {
+    mount(<RecordHistoryPanel client={clientFor(page([rev({ version: 1 })]))} />)
+    await screen.findByText('jurga@ogmc.example')
+    const panel = screen.getByTestId('record-history-panel')
+    expect(panel.textContent).not.toMatch(/bulk imports|scope moves|not recorded yet/i)
+    expect(screen.queryByTestId('record-history-incomplete')).not.toBeInTheDocument()
+  })
+
+  it('an empty history says "No edits recorded" and nothing more when history is on or unknown', async () => {
+    mount(<RecordHistoryPanel client={clientFor(page([]))} />)
+    await screen.findByText('No edits recorded for this record')
+    expect(screen.queryByTestId('record-history-incomplete')).not.toBeInTheDocument()
+    expect(screen.queryByTestId('record-history-declared-off')).not.toBeInTheDocument()
+  })
+
+  it('says history is not recorded for this kind of record when the type declares it off', async () => {
+    mount(<RecordHistoryPanel client={clientFor(page([]))} historyEnabled={false} />)
+    const note = await screen.findByTestId('record-history-declared-off')
+    expect(note).toHaveTextContent(/history is not recorded for this kind of record/i)
+    // A declaration, not a defect — it must not read like missing data.
+    expect(note.textContent).not.toMatch(/may be missing|error|fail|broken/i)
+    // And the empty state must not suggest edits will appear.
+    expect(screen.queryByText(/will appear here/i)).not.toBeInTheDocument()
+  })
+
+  it('keeps the declared-off disclosure next to rows recorded before it was switched off', async () => {
+    mount(
+      <RecordHistoryPanel client={clientFor(page([rev({ version: 1 })]))} historyEnabled={false} />,
+    )
+    expect(await screen.findByText('jurga@ogmc.example')).toBeInTheDocument()
+    expect(screen.getByTestId('record-history-declared-off')).toHaveTextContent(
+      /history is not recorded for this kind of record/i,
+    )
+  })
+
+  it('says nothing about a declaration when the type keeps history', async () => {
+    mount(<RecordHistoryPanel client={clientFor(page([]))} historyEnabled />)
+    await screen.findByText('No edits recorded for this record')
+    expect(screen.queryByTestId('record-history-declared-off')).not.toBeInTheDocument()
+  })
+})
+
+describe('RevisionFields — the before/after split sizes on its container (bd startsim-jkkn7.12)', () => {
+  it('never decides the split from the VIEWPORT', async () => {
+    mount(<RecordHistoryPanel client={clientFor(page([rev({ version: 1 })]))} />)
+    fireEvent.click(await screen.findByRole('button', { name: /blog/ }))
+    const before = screen.getByText('Before')
+    const split = before.parentElement!.parentElement!
+    // `sm:`/`md:`/`lg:` are viewport media queries: on a wide screen they force
+    // the two sides next to each other even inside a 370px rail.
+    expect(split.className).not.toMatch(/(^|\s)(sm|md|lg|xl):/)
+    // Stacked by default, side by side only when the CONTAINER has room.
+    expect(split.className).toMatch(/@sm:/)
+    expect(split.closest('.\\@container')).not.toBeNull()
+  })
+
+  it('gives the field list the full card width, not a column beside the timestamp', async () => {
+    // Measured in a 366px rail: the detail sat in the header's left column and
+    // shared the line with "2 minutes ago", losing ~100px it never needed.
+    mount(<RecordHistoryPanel client={clientFor(page([rev({ version: 1 })]))} />)
+    const fields = await screen.findByTestId('revision-fields')
+    const row = fields.closest('[data-activity-id]')!
+    const time = within(row as HTMLElement).getByText(/ago|\d{1,2}:\d{2}/)
+    // The timestamp's row must not contain the field list.
+    expect(time.parentElement!.contains(fields)).toBe(false)
   })
 })
 
@@ -308,5 +372,89 @@ describe('ActorIdentity — the kind props are additive', () => {
     render(<ActorIdentity actor={{ email: 'a@b.com' }} kind="unknown" />)
     const el = screen.getByTestId('actor-identity')
     expect(el).toHaveAttribute('data-actor-kind', 'unknown')
+    expect(el).toHaveAttribute(
+      'title',
+      'Whether a person or a machine made this change was not recorded.',
+    )
+  })
+})
+
+describe('ActorIdentity — every row with a kind can say it (bd startsim-jkkn7.15)', () => {
+  it('titles a claimed person, the other undecorated case', () => {
+    render(<ActorIdentity actor={{ email: 'malin@ogmc.example' }} kind="person" kindSource="claim" />)
+    expect(screen.getByTestId('actor-identity')).toHaveAttribute(
+      'title',
+      'A person made this change (declared by the sign-in service).',
+    )
+  })
+
+  it('titles a marked machine row on the wrapper too', () => {
+    render(<ActorIdentity actor={{ email: 'svc@x' }} kind="machine" kindSource="claim" />)
+    expect(screen.getByTestId('actor-identity')).toHaveAttribute(
+      'title',
+      'A machine made this change (declared by the sign-in service).',
+    )
+  })
+
+  it('keeps the kind out of the text, because the chip sits inside sentences', () => {
+    render(<ActorIdentity actor={{ email: 'a@b.com' }} kind="unknown" showInitials={false} />)
+    expect(screen.getByTestId('actor-identity')).toHaveTextContent(/^a@b\.com$/)
+  })
+
+  it('adds no title when no kind is passed (older surfaces stay byte-identical)', () => {
+    render(<ActorIdentity actor={{ email: 'a@b.com' }} />)
+    expect(screen.getByTestId('actor-identity')).not.toHaveAttribute('title')
+  })
+
+  it('titles every row in the panel, including unknown and person/claim', async () => {
+    mount(
+      <RecordHistoryPanel
+        windowMs={0}
+        client={clientFor(
+          page([
+            rev({ version: 4, actor_label: 'u4@x', actor_sub: 'u4', actor_kind: 'unknown', actor_kind_source: 'inferred' }),
+            rev({ version: 3, actor_label: 'malin@x', actor_sub: 'u3', created_at: at(-60_000) }),
+            rev({ version: 2, actor_label: 'svc:a', actor_sub: 'svc:a', created_at: at(-120_000), actor_kind: 'machine', actor_kind_source: 'inferred' }),
+            rev({ version: 1, actor_label: 'svc:b', actor_sub: 'svc:b', created_at: at(-180_000), actor_kind: 'machine', actor_kind_source: 'claim' }),
+          ]),
+        )}
+      />,
+    )
+    await screen.findByText('malin@x')
+    const rows = screen.getAllByTestId('actor-identity')
+    expect(rows).toHaveLength(4)
+    for (const row of rows) expect(row.getAttribute('title')).toBeTruthy()
+  })
+})
+
+describe('RecordHistoryPanel — the unrecorded-kind sentence is scoped (bd startsim-jkkn7.15)', () => {
+  it('does not sweep a recorded person into "the rest"', async () => {
+    mount(
+      <RecordHistoryPanel
+        windowMs={0}
+        client={clientFor(
+          page([
+            rev({ version: 2, actor_label: 'u2@x', actor_sub: 'u2', actor_kind: 'unknown', actor_kind_source: 'inferred' }),
+            rev({ version: 1, actor_label: 'malin@x', actor_sub: 'u1', created_at: at(-60_000) }),
+          ]),
+        )}
+      />,
+    )
+    const note = await screen.findByTestId('record-history-unknown-kind')
+    expect(note.textContent).not.toMatch(/for the rest/i)
+    // It says that SOME unmarked entries were recorded as a person, and where
+    // to find out which.
+    expect(note.textContent).toMatch(/some unmarked entries/i)
+    expect(note.textContent).toMatch(/person/i)
+  })
+
+  it('keeps the plain wording when no loaded row is a recorded person', async () => {
+    mount(
+      <RecordHistoryPanel
+        client={clientFor(page([rev({ version: 1, actor_kind: 'unknown', actor_kind_source: 'inferred' })]))}
+      />,
+    )
+    const note = await screen.findByTestId('record-history-unknown-kind')
+    expect(note.textContent).toMatch(/for the rest/i)
   })
 })

package/src/components/history/record-history-panel-default-class-names.ts

@@ -10,7 +10,7 @@ export interface RecordHistoryPanelClassNames {
   description?: string;
   body?: string;
   /** The panel-level sentences: the unrecorded-kind explanation, the redaction
-   *  notice and the "some write paths are not recorded" caveat. */
+   *  notice and the declared-off disclosure. */
   notice?: string;
   footer?: string;
   countLine?: string;