@startsimpli/ui 0.4.135 → 0.4.137

package/src/components/history/__tests__/revision-history.test.ts

@@ -0,0 +1,355 @@
+/**
+ * The fold, and what one field change SAYS (bd startsim-g4rwo).
+ *
+ * Every case here is one of the server contract's edge cases that a naive
+ * reading gets wrong — absence vs null, truncation gating the delete
+ * inference, `{}` meaning three different things, and the four fold refusals.
+ * Pure module, so none of it needs a render or a backend.
+ */
+import {
+  COLLAPSE_WINDOW_MS,
+  actorKindOf,
+  actorKindSourceOf,
+  canDiffFieldChange,
+  classifyFieldChange,
+  foldRevisions,
+  normalizeFieldChange,
+  normalizeRevision,
+  sittingHeadline,
+  sittingSummary,
+} from '../revision-history'
+import type { EntityRevision } from '../types'
+
+const T0 = Date.parse('2026-10-05T12:00:00.000Z')
+const at = (msAfter: number) => new Date(T0 + msAfter).toISOString()
+
+function rev(over: Partial<EntityRevision> & { version: number }): EntityRevision {
+  return {
+    id: `r${over.version}`,
+    action: 'updated',
+    source: 'patch',
+    precondition: 'none',
+    created_at: at(0),
+    actor_sub: 'u1',
+    actor_label: 'jurga@ogmc.example',
+    actor_kind: 'person',
+    actor_kind_source: 'claim',
+    metadata: { changed: {} },
+    ...over,
+  }
+}
+
+describe('actorKindOf — three-state, failing closed', () => {
+  it('reads person and machine', () => {
+    expect(actorKindOf(rev({ version: 1, actor_kind: 'person' }))).toBe('person')
+    expect(actorKindOf(rev({ version: 1, actor_kind: 'machine' }))).toBe('machine')
+  })
+
+  it('reads an ABSENT kind as unknown, never as person', () => {
+    expect(actorKindOf({ id: 'x', version: 1 })).toBe('unknown')
+    expect(actorKindOf(rev({ version: 1, actor_kind: null }))).toBe('unknown')
+    expect(actorKindOf(rev({ version: 1, actor_kind: '' }))).toBe('unknown')
+  })
+
+  it('reads a value from outside the vocabulary as unknown', () => {
+    expect(actorKindOf(rev({ version: 1, actor_kind: 'robot' }))).toBe('unknown')
+  })
+
+  it('reads the CAMELISED spelling the shared API client produces', () => {
+    expect(actorKindOf({ id: 'x', version: 1, actorKind: 'machine' })).toBe('machine')
+    expect(actorKindSourceOf({ id: 'x', version: 1, actorKindSource: 'inferred' })).toBe('inferred')
+  })
+
+  it('distinguishes a claimed kind from an inferred one', () => {
+    expect(actorKindSourceOf(rev({ version: 1, actor_kind_source: 'claim' }))).toBe('claim')
+    expect(actorKindSourceOf(rev({ version: 1, actor_kind_source: 'inferred' }))).toBe('inferred')
+    expect(actorKindSourceOf({ id: 'x', version: 1 })).toBeUndefined()
+  })
+})
+
+describe('normalizeFieldChange — absence is the payload', () => {
+  it('a CREATED key has after and no before', () => {
+    const c = normalizeFieldChange({ after: 'hello' })
+    expect(c.hasBefore).toBe(false)
+    expect(c.hasAfter).toBe(true)
+    expect(classifyFieldChange(c)).toBe('created')
+  })
+
+  it('a DELETED key has before and no after', () => {
+    const c = normalizeFieldChange({ before: 'gone' })
+    expect(c.hasAfter).toBe(false)
+    expect(classifyFieldChange(c)).toBe('deleted')
+  })
+
+  it('a key set to NULL is an update, not a deletion — null is a real value', () => {
+    const c = normalizeFieldChange({ before: 'x', after: null })
+    expect(c.hasAfter).toBe(true)
+    expect(c.after).toBeNull()
+    expect(classifyFieldChange(c)).toBe('updated')
+  })
+
+  it('a key created AS null is created, not deleted', () => {
+    const c = normalizeFieldChange({ after: null })
+    expect(classifyFieldChange(c)).toBe('created')
+  })
+
+  it('a WITHHELD key is {} and classifies as withheld, not as a deletion', () => {
+    expect(classifyFieldChange(normalizeFieldChange({}, { withheld: true }))).toBe('withheld')
+  })
+
+  it('an OMITTED row’s key is {} and classifies as omitted', () => {
+    expect(classifyFieldChange(normalizeFieldChange({}, { omitted: true }))).toBe('omitted')
+  })
+
+  it('TRUNCATION WINS over the delete inference — a missing side says nothing', () => {
+    // before present, after absent, but truncated: this is NOT a deletion.
+    const c = normalizeFieldChange({ before: 'a very long prefix', truncated: true })
+    expect(classifyFieldChange(c)).toBe('truncated')
+    expect(classifyFieldChange(c)).not.toBe('deleted')
+  })
+
+  it('refuses to diff a truncated, withheld or omitted side', () => {
+    expect(canDiffFieldChange(normalizeFieldChange({ before: 'a', after: 'b', truncated: true }))).toBe(false)
+    expect(canDiffFieldChange(normalizeFieldChange({}, { withheld: true }))).toBe(false)
+    expect(canDiffFieldChange(normalizeFieldChange({}, { omitted: true }))).toBe(false)
+  })
+
+  it('diffs only when both sides are text', () => {
+    expect(canDiffFieldChange(normalizeFieldChange({ before: 'a', after: 'b' }))).toBe(true)
+    expect(canDiffFieldChange(normalizeFieldChange({ before: { a: 1 }, after: { a: 2 } }))).toBe(false)
+    expect(canDiffFieldChange(normalizeFieldChange({ after: 'new' }))).toBe(false)
+  })
+})
+
+describe('normalizeRevision', () => {
+  it('marks a field named in redacted_fields as withheld', () => {
+    const n = normalizeRevision(
+      rev({ version: 3, metadata: { changed: { body: {} } }, redacted_fields: ['body'] }),
+    )
+    expect(n.changed.body!.withheld).toBe(true)
+    expect(n.redacted).toEqual(['body'])
+  })
+
+  it('marks every field omitted when the ROW was over the cap', () => {
+    const n = normalizeRevision(
+      rev({ version: 3, metadata: { changed: { a: {}, b: {} }, values_omitted: true } }),
+    )
+    expect(n.valuesOmitted).toBe(true)
+    expect(n.changed.a!.omitted).toBe(true)
+    expect(n.changed.b!.omitted).toBe(true)
+  })
+
+  it('reads values_omitted in its camelised spelling too', () => {
+    const n = normalizeRevision(rev({ version: 1, metadata: { changed: { a: {} }, valuesOmitted: true } }))
+    expect(n.valuesOmitted).toBe(true)
+  })
+
+  it('a PRESERVED row with no changes is an ATTEMPT', () => {
+    const n = normalizeRevision(
+      rev({ version: 4, metadata: { changed: {}, preserved: ['blog'] } }),
+    )
+    expect(n.isAttempt).toBe(true)
+    expect(n.preserved).toEqual(['blog'])
+  })
+
+  it('a row that both changed and preserved something is NOT an attempt', () => {
+    const n = normalizeRevision(
+      rev({ version: 4, metadata: { changed: { seo: { after: 'x' } }, preserved: ['blog'] } }),
+    )
+    expect(n.isAttempt).toBe(false)
+  })
+
+  it('survives a row with no metadata at all', () => {
+    const n = normalizeRevision({ id: 'x', version: 1 })
+    expect(n.changed).toEqual({})
+    expect(n.isAttempt).toBe(false)
+    expect(n.actorKind).toBe('unknown')
+  })
+})
+
+describe('foldRevisions', () => {
+  it('folds consecutive same-actor saves inside the window into one sitting', () => {
+    const rows = [
+      rev({ version: 3, created_at: at(4000), metadata: { changed: { blog: { before: 'b', after: 'c' } } } }),
+      rev({ version: 2, created_at: at(2000), metadata: { changed: { blog: { before: 'a', after: 'b' } } } }),
+      rev({ version: 1, created_at: at(0), action: 'created', metadata: { changed: { blog: { after: 'a' } } } }),
+    ]
+    const folded = foldRevisions(rows)
+    // The create does not absorb the later edits.
+    expect(folded).toHaveLength(2)
+    expect(folded[0]!.saves).toBe(2)
+    expect(folded[1]!.action).toBe('created')
+  })
+
+  it('takes BEFORE from the oldest row and AFTER from the newest', () => {
+    const rows = [
+      rev({ version: 3, created_at: at(4000), metadata: { changed: { blog: { before: 'two', after: 'three' } } } }),
+      rev({ version: 2, created_at: at(2000), metadata: { changed: { blog: { before: 'one', after: 'two' } } } }),
+    ]
+    const [sitting] = foldRevisions(rows)
+    expect(sitting!.changed.blog!.before).toBe('one')
+    expect(sitting!.changed.blog!.after).toBe('three')
+    expect(sitting!.fromVersion).toBe(2)
+    expect(sitting!.toVersion).toBe(3)
+  })
+
+  it('does not fold across the window', () => {
+    const rows = [
+      rev({ version: 2, created_at: at(COLLAPSE_WINDOW_MS + 1000) }),
+      rev({ version: 1, created_at: at(0) }),
+    ]
+    expect(foldRevisions(rows)).toHaveLength(2)
+  })
+
+  it('does not fold two different actors', () => {
+    const rows = [
+      rev({ version: 2, created_at: at(1000), actor_sub: 'u2', actor_label: 'b@x' }),
+      rev({ version: 1, created_at: at(0), actor_sub: 'u1', actor_label: 'a@x' }),
+    ]
+    expect(foldRevisions(rows)).toHaveLength(2)
+  })
+
+  it('REFUSES to fold across a differing actor_kind even when the sub matches', () => {
+    // The healing window: one person's rows read unknown then person. Folding
+    // would stamp the sitting with whichever end won.
+    const rows = [
+      rev({ version: 2, created_at: at(1000), actor_kind: 'person', actor_kind_source: 'claim' }),
+      rev({ version: 1, created_at: at(0), actor_kind: 'unknown', actor_kind_source: 'inferred' }),
+    ]
+    const folded = foldRevisions(rows)
+    expect(folded).toHaveLength(2)
+    expect(folded[0]!.actorKind).toBe('person')
+    expect(folded[1]!.actorKind).toBe('unknown')
+  })
+
+  it('REFUSES to fold across a differing actor_kind_source', () => {
+    const rows = [
+      rev({ version: 2, created_at: at(1000), actor_kind_source: 'claim' }),
+      rev({ version: 1, created_at: at(0), actor_kind_source: 'inferred' }),
+    ]
+    expect(foldRevisions(rows)).toHaveLength(2)
+  })
+
+  it('REFUSES to fold an ATTEMPT into a change', () => {
+    const rows = [
+      rev({
+        version: 2,
+        created_at: at(1000),
+        actor_sub: 'svc:n8n',
+        actor_kind: 'machine',
+        actor_kind_source: 'inferred',
+        metadata: { changed: {}, preserved: ['blog'] },
+      }),
+      rev({
+        version: 1,
+        created_at: at(0),
+        actor_sub: 'svc:n8n',
+        actor_kind: 'machine',
+        actor_kind_source: 'inferred',
+        metadata: { changed: { seo: { after: 'x' } } },
+      }),
+    ]
+    const folded = foldRevisions(rows)
+    expect(folded).toHaveLength(2)
+    expect(folded[0]!.isAttempt).toBe(true)
+    expect(folded[1]!.isAttempt).toBe(false)
+  })
+
+  it('folds two attempts together', () => {
+    const rows = [
+      rev({ version: 2, created_at: at(1000), metadata: { changed: {}, preserved: ['seo'] } }),
+      rev({ version: 1, created_at: at(0), metadata: { changed: {}, preserved: ['blog'] } }),
+    ]
+    const folded = foldRevisions(rows)
+    expect(folded).toHaveLength(1)
+    expect(folded[0]!.preserved).toEqual(['blog', 'seo'])
+  })
+
+  it('carries a withheld flag FORWARD through a fold rather than dropping it', () => {
+    const rows = [
+      rev({ version: 2, created_at: at(1000), metadata: { changed: { body: { before: 'x', after: 'y' } } } }),
+      rev({ version: 1, created_at: at(0), metadata: { changed: { body: {} } }, redacted_fields: ['body'] }),
+    ]
+    const [sitting] = foldRevisions(rows)
+    expect(sitting!.saves).toBe(2)
+    expect(sitting!.changed.body!.withheld).toBe(true)
+    expect(sitting!.redacted).toEqual(['body'])
+    expect(canDiffFieldChange(sitting!.changed.body!)).toBe(false)
+  })
+
+  it('carries a truncated flag forward, so a fold never produces a clean diff from a capped side', () => {
+    const rows = [
+      rev({ version: 2, created_at: at(1000), metadata: { changed: { blog: { before: 'b', after: 'c' } } } }),
+      rev({ version: 1, created_at: at(0), metadata: { changed: { blog: { before: 'a', truncated: true } } } }),
+    ]
+    const [sitting] = foldRevisions(rows)
+    expect(sitting!.changed.blog!.truncated).toBe(true)
+    expect(canDiffFieldChange(sitting!.changed.blog!)).toBe(false)
+  })
+
+  it('windowMs of 0 renders a row per save', () => {
+    const rows = [
+      rev({ version: 2, created_at: at(1000) }),
+      rev({ version: 1, created_at: at(0) }),
+    ]
+    expect(foldRevisions(rows, 0)).toHaveLength(2)
+  })
+
+  it('treats an out-of-order clock as the same sitting rather than inventing a precedence', () => {
+    const rows = [rev({ version: 2, created_at: at(0) }), rev({ version: 1, created_at: at(0) })]
+    expect(foldRevisions(rows)).toHaveLength(1)
+  })
+
+  it('returns nothing for an empty trail', () => {
+    expect(foldRevisions([])).toEqual([])
+  })
+})
+
+describe('sittingSummary / sittingHeadline', () => {
+  const sit = (rows: EntityRevision[]) => foldRevisions(rows)[0]!
+
+  it('a single save does not claim to be a sitting', () => {
+    expect(sittingSummary(sit([rev({ version: 1 })]))).toBe('1 save')
+  })
+
+  it('a collapsed sitting says it is a collapse, with its span', () => {
+    const rows = [
+      rev({ version: 2, created_at: at(120_000) }),
+      rev({ version: 1, created_at: at(0) }),
+    ]
+    expect(sittingSummary(sit(rows))).toBe('2 saves over 2 min')
+  })
+
+  it('a sub-minute burst reports the count without a misleading 0 min', () => {
+    const rows = [rev({ version: 2, created_at: at(3000) }), rev({ version: 1, created_at: at(0) })]
+    expect(sittingSummary(sit(rows))).toBe('2 saves')
+  })
+
+  it('names the fields it edited', () => {
+    const s = sit([rev({ version: 1, metadata: { changed: { blog: { after: 'x' }, seo: { after: 'y' } } } })])
+    expect(sittingHeadline(s)).toBe('Edited blog and seo')
+  })
+
+  it('counts instead of listing beyond three fields', () => {
+    const changed = Object.fromEntries(['a', 'b', 'c', 'd'].map((k) => [k, { after: '1' }]))
+    const s = sit([rev({ version: 1, metadata: { changed } })])
+    expect(sittingHeadline(s)).toBe('Edited 4 fields')
+  })
+
+  it('AN ATTEMPT READS AS AN ATTEMPT — the sentence nobody could produce', () => {
+    const s = sit([
+      rev({ version: 1, metadata: { changed: {}, preserved: ['team_verdict'] } }),
+    ])
+    expect(sittingHeadline(s)).toBe('Tried to write team_verdict — held back')
+  })
+
+  it('a name-only move reads as a rename', () => {
+    const s = sit([rev({ version: 2, metadata: { changed: {}, name: { before: 'a', after: 'b' } } })])
+    expect(sittingHeadline(s)).toBe('Renamed the record')
+  })
+
+  it('applies a fieldLabel mapping', () => {
+    const s = sit([rev({ version: 1, metadata: { changed: { team_verdict: { after: 'x' } } } })])
+    expect(sittingHeadline(s, (f) => f.replace('_', ' '))).toBe('Edited team verdict')
+  })
+})

package/src/components/history/__tests__/stale-save-dialog.test.tsx

@@ -0,0 +1,224 @@
+/**
+ * What the reviewer sees when a stale save is refused (bd startsim-jkkn7.3).
+ */
+import { fireEvent, render, screen } from '@testing-library/react';
+
+import { StaleSaveDialog } from '../StaleSaveDialog';
+import { normalizeRevision } from '../revision-history';
+import type { StaleSaveConflict } from '../useConditionalSave';
+
+const base: StaleSaveConflict = {
+  currentVersion: 3,
+  sentVersion: 2,
+  detail: 'the record changed since it was loaded: version 2 was sent and the record is now at version 3.',
+  refusedBody: { data: { blog: 'three paragraphs' } },
+};
+
+const changedBy = (over: Record<string, unknown> = {}) =>
+  normalizeRevision({
+    id: 'r3',
+    version: 3,
+    created_at: '2026-10-06T12:00:00Z',
+    actor_label: 'jurga@ogmc.example',
+    actor_kind: 'person',
+    actor_kind_source: 'claim',
+    metadata: { changed: { blog: { before: 'a', after: 'b' }, judge_verdict: { after: 'pass' } } },
+    ...over,
+  } as never);
+
+describe('it says the text is safe before it says anything else', () => {
+  it('leads with the reassurance', () => {
+    render(<StaleSaveDialog conflict={base} onDismiss={jest.fn()} />);
+    expect(screen.getByTestId('stale-save-reassurance')).toHaveTextContent(
+      'Your edits are still here and have not been saved.',
+    );
+  });
+
+  it('renders nothing without a conflict, and nothing when closed', () => {
+    const { container, rerender } = render(
+      <StaleSaveDialog conflict={null} onDismiss={jest.fn()} />,
+    );
+    expect(container).toBeEmptyDOMElement();
+    rerender(<StaleSaveDialog conflict={base} open={false} onDismiss={jest.fn()} />);
+    expect(container).toBeEmptyDOMElement();
+  });
+});
+
+describe('who changed it', () => {
+  it('names the person in the headline', () => {
+    render(<StaleSaveDialog conflict={{ ...base, changedBy: changedBy() }} onDismiss={jest.fn()} />);
+    expect(screen.getByTestId('stale-save-title')).toHaveTextContent(
+      /jurga@ogmc\.example\s*changed this record while you were editing\./,
+    );
+  });
+
+  it('marks a machine, because a machine overwriting a human is the case this epic exists for', () => {
+    render(
+      <StaleSaveDialog
+        conflict={{
+          ...base,
+          changedBy: changedBy({ actor_label: 'svc:n8n-ogmc', actor_kind: 'machine' }),
+        }}
+        onDismiss={jest.fn()}
+      />,
+    );
+    expect(screen.getByTestId('actor-kind')).toHaveTextContent('machine');
+  });
+
+  it('NEVER renders an unrecorded kind as a machine', () => {
+    // `unknown` means central did not say. The claim is minted at login, so for
+    // up to the 14-day refresh expiry a genuine human edit carries no kind.
+    render(
+      <StaleSaveDialog
+        conflict={{ ...base, changedBy: changedBy({ actor_kind: undefined, actor_kind_source: undefined }) }}
+        onDismiss={jest.fn()}
+      />,
+    );
+    expect(screen.getByTestId('actor-identity')).toHaveAttribute('data-actor-kind', 'unknown');
+    expect(screen.queryByTestId('actor-kind')).not.toBeInTheDocument();
+    expect(screen.getByTestId('stale-save-dialog')).not.toHaveTextContent(/machine/i);
+  });
+
+  it('says the record changed without guessing at a person when the trail said nobody', () => {
+    render(
+      <StaleSaveDialog
+        conflict={{ ...base, identityGap: 'forbidden' }}
+        onDismiss={jest.fn()}
+      />,
+    );
+    expect(screen.getByTestId('stale-save-title')).toHaveTextContent(
+      'This record changed while you were editing.',
+    );
+    expect(screen.getByTestId('stale-save-identity-gap')).toHaveTextContent(
+      /history is not available to you/,
+    );
+  });
+
+  it('shows the fields verbatim, never recased', () => {
+    render(<StaleSaveDialog conflict={{ ...base, changedBy: changedBy() }} onDismiss={jest.fn()} />);
+    const fields = screen.getByTestId('stale-save-fields');
+    expect(fields).toHaveTextContent('blog');
+    expect(fields).toHaveTextContent('judge_verdict');
+    expect(fields).not.toHaveTextContent('judgeVerdict');
+  });
+
+  it("shows the server's own sentence", () => {
+    render(<StaleSaveDialog conflict={base} onDismiss={jest.fn()} />);
+    expect(screen.getByTestId('stale-save-detail')).toHaveTextContent('now at version 3');
+  });
+});
+
+describe('the accidental paths dismiss and resolve nothing', () => {
+  it('Escape dismisses', () => {
+    const onDismiss = jest.fn();
+    const onKeepMine = jest.fn();
+    const onAcceptTheirs = jest.fn();
+    render(
+      <StaleSaveDialog
+        conflict={base}
+        onDismiss={onDismiss}
+        onKeepMine={onKeepMine}
+        onAcceptTheirs={onAcceptTheirs}
+      />,
+    );
+
+    fireEvent.keyDown(document, { key: 'Escape' });
+
+    expect(onDismiss).toHaveBeenCalledTimes(1);
+    expect(onKeepMine).not.toHaveBeenCalled();
+    expect(onAcceptTheirs).not.toHaveBeenCalled();
+  });
+
+  it('the backdrop dismisses, and a click inside does not', () => {
+    const onDismiss = jest.fn();
+    render(<StaleSaveDialog conflict={base} onDismiss={onDismiss} />);
+
+    fireEvent.click(screen.getByTestId('stale-save-dialog'));
+    expect(onDismiss).not.toHaveBeenCalled();
+
+    fireEvent.click(screen.getByTestId('stale-save-backdrop'));
+    expect(onDismiss).toHaveBeenCalledTimes(1);
+  });
+
+  it('focuses a control that can neither write nor discard', () => {
+    const { unmount } = render(
+      <StaleSaveDialog
+        conflict={base}
+        onDismiss={jest.fn()}
+        onKeepMine={jest.fn()}
+        onAcceptTheirs={jest.fn()}
+        onReviewChange={jest.fn()}
+      />,
+    );
+    expect(screen.getByTestId('stale-save-review')).toHaveFocus();
+    unmount();
+
+    render(
+      <StaleSaveDialog conflict={base} onDismiss={jest.fn()} onKeepMine={jest.fn()} />,
+    );
+    expect(screen.getByTestId('stale-save-dismiss')).toHaveFocus();
+  });
+});
+
+describe('the actions', () => {
+  it('labels the overwrite with what it does to their change', () => {
+    render(<StaleSaveDialog conflict={base} onDismiss={jest.fn()} onKeepMine={jest.fn()} />);
+    expect(screen.getByTestId('stale-save-keep-mine')).toHaveTextContent(
+      'Save mine, replacing their change',
+    );
+  });
+
+  it('offers each action only when the host handles it', () => {
+    render(<StaleSaveDialog conflict={base} onDismiss={jest.fn()} />);
+    expect(screen.queryByTestId('stale-save-keep-mine')).not.toBeInTheDocument();
+    expect(screen.queryByTestId('stale-save-accept-theirs')).not.toBeInTheDocument();
+    expect(screen.queryByTestId('stale-save-review')).not.toBeInTheDocument();
+    // Dismissal is always available: there is always a way back to the text.
+    expect(screen.getByTestId('stale-save-dismiss')).toBeInTheDocument();
+  });
+
+  it('fires the handlers', () => {
+    const onKeepMine = jest.fn();
+    const onAcceptTheirs = jest.fn();
+    const onReviewChange = jest.fn();
+    render(
+      <StaleSaveDialog
+        conflict={base}
+        onDismiss={jest.fn()}
+        onKeepMine={onKeepMine}
+        onAcceptTheirs={onAcceptTheirs}
+        onReviewChange={onReviewChange}
+      />,
+    );
+
+    fireEvent.click(screen.getByTestId('stale-save-keep-mine'));
+    fireEvent.click(screen.getByTestId('stale-save-accept-theirs'));
+    fireEvent.click(screen.getByTestId('stale-save-review'));
+
+    expect(onKeepMine).toHaveBeenCalledTimes(1);
+    expect(onAcceptTheirs).toHaveBeenCalledTimes(1);
+    expect(onReviewChange).toHaveBeenCalledTimes(1);
+  });
+
+  it('disables the writing actions while a resolution is in flight, but never the way back', () => {
+    render(
+      <StaleSaveDialog
+        conflict={base}
+        busy
+        onDismiss={jest.fn()}
+        onKeepMine={jest.fn()}
+        onAcceptTheirs={jest.fn()}
+      />,
+    );
+    expect(screen.getByTestId('stale-save-keep-mine')).toBeDisabled();
+    expect(screen.getByTestId('stale-save-accept-theirs')).toBeDisabled();
+    expect(screen.getByTestId('stale-save-dismiss')).toBeEnabled();
+  });
+
+  it('is a labelled modal', () => {
+    render(<StaleSaveDialog conflict={base} onDismiss={jest.fn()} />);
+    const dialog = screen.getByRole('dialog');
+    expect(dialog).toHaveAttribute('aria-modal', 'true');
+    expect(dialog).toHaveAttribute('aria-labelledby', 'stale-save-title');
+  });
+});

package/src/components/history/__tests__/text-diff.test.ts

@@ -0,0 +1,59 @@
+/**
+ * Ported from marketing-agents-web `src/lib/__tests__/blog-diff.test.ts` with
+ * the module (bd startsim-g4rwo). Same assertions, jest instead of vitest, and
+ * the generic `unifiedTextDiff` name — see `text-diff.ts` on the rename.
+ */
+import { parseDiffFiles } from '../../diff'
+import { diffLines, unifiedTextDiff } from '../text-diff'
+
+describe('diffLines', () => {
+  it('marks equal / deleted / inserted lines in output order', () => {
+    expect(diffLines(['a', 'b', 'c'], ['a', 'x', 'c'])).toEqual([
+      { type: 'eq', line: 'a' },
+      { type: 'del', line: 'b' },
+      { type: 'ins', line: 'x' },
+      { type: 'eq', line: 'c' },
+    ])
+  })
+})
+
+describe('unifiedTextDiff', () => {
+  it('returns "" for identical values', () => {
+    expect(unifiedTextDiff('same\ntext', 'same\ntext')).toBe('')
+  })
+
+  it('emits a git-style block the shared DiffViewer parser can read', () => {
+    const diff = unifiedTextDiff(
+      'Line one\nLine two\nLine three',
+      'Line one\nLine 2\nLine three',
+      'blog',
+    )
+    expect(diff).toContain('diff --git a/blog b/blog')
+    expect(diff).toMatch(/^@@ -\d+,\d+ \+\d+,\d+ @@$/m)
+    expect(diff).toContain('-Line two')
+    expect(diff).toContain('+Line 2')
+    const files = parseDiffFiles(diff)
+    expect(files).toHaveLength(1)
+    expect(files[0]!.filePath).toBe('blog')
+  })
+
+  it('keeps context lines but not the whole document', () => {
+    const oldText = Array.from({ length: 20 }, (_, i) => `line ${i}`).join('\n')
+    const newText = oldText.replace('line 10', 'LINE TEN')
+    const body = unifiedTextDiff(oldText, newText)
+      .split('\n')
+      .filter((l) => /^[ +-]/.test(l) && !l.startsWith('+++') && !l.startsWith('---'))
+    expect(body).toContain('-line 10')
+    expect(body).toContain('+LINE TEN')
+    expect(body).toContain(' line 7')
+    expect(body).not.toContain(' line 0')
+  })
+
+  it('names the field in the header, so the rendered diff says what moved', () => {
+    expect(unifiedTextDiff('a', 'b', 'linkedin')).toContain('diff --git a/linkedin b/linkedin')
+  })
+
+  it('tolerates CRLF and a trailing newline without inventing a last line', () => {
+    expect(unifiedTextDiff('a\r\nb\r\n', 'a\nb\n')).toBe('')
+  })
+})