diff --git a/src/app/(app)/ledger/close/__tests__/ChangedTransactionsPanel.test.tsx b/src/app/(app)/ledger/close/__tests__/ChangedTransactionsPanel.test.tsx
new file mode 100644
index 0000000..0ff6459
--- /dev/null
+++ b/src/app/(app)/ledger/close/__tests__/ChangedTransactionsPanel.test.tsx
@@ -0,0 +1,491 @@
+import { fireEvent, render, screen, waitFor } from '@testing-library/react'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mockListEventBlocks = vi.fn()
+const mockPreviewReconcilingItem = vi.fn()
+const mockResolveReconcilingItem = vi.fn()
+
+vi.mock('@robosystems/core', () => ({
+  clients: {
+    ledger: {
+      listEventBlocks: (...args: any[]) => mockListEventBlocks(...args),
+      previewReconcilingItem: (...args: any[]) =>
+        mockPreviewReconcilingItem(...args),
+      resolveReconcilingItem: (...args: any[]) =>
+        mockResolveReconcilingItem(...args),
+    },
+  },
+  LoadingState: () => (
+    <div data-testid="loading-state" role="status">
+      Loading
+    </div>
+  ),
+}))
+
+vi.mock('flowbite-react', () => ({
+  Button: ({ children, onClick, disabled }: any) => (
+    <button onClick={onClick} disabled={disabled}>
+      {children}
+    </button>
+  ),
+  Label: ({ children, htmlFor }: any) => (
+    <label htmlFor={htmlFor}>{children}</label>
+  ),
+  Spinner: () => <span data-testid="spinner" />,
+  Table: ({ children }: any) => <table>{children}</table>,
+  TableBody: ({ children }: any) => <tbody>{children}</tbody>,
+  TableCell: ({ children }: any) => <td>{children}</td>,
+  TableHead: ({ children }: any) => <thead>{children}</thead>,
+  TableHeadCell: ({ children }: any) => <th>{children}</th>,
+  TableRow: ({ children }: any) => <tr>{children}</tr>,
+  Textarea: ({ value, onChange, id }: any) => (
+    <textarea id={id} value={value} onChange={onChange} />
+  ),
+}))
+
+vi.mock('react-icons/hi', () => ({
+  HiCheckCircle: () => <span />,
+  HiExclamationCircle: () => <span />,
+}))
+
+import ChangedTransactionsPanel from '../components/ChangedTransactionsPanel'
+
+const event = (overrides: Record<string, unknown> = {}) => ({
+  id: 'evt_invoice',
+  eventType: 'invoice_issued',
+  occurredAt: '2026-07-14T00:00:00Z',
+  externalId: 'qb-inv-1042',
+  externalUrl: null,
+  source: 'quickbooks',
+  amount: 150000,
+  currency: 'USD',
+  description: 'Invoice 1042 to Northwind',
+  ...overrides,
+})
+
+const plan = (overrides: Record<string, unknown> = {}) => ({
+  event_id: 'evt_invoice',
+  source: 'quickbooks',
+  event_type: 'invoice_issued',
+  event_status: 'fulfilled',
+  default_disposition: 'restate',
+  default_posting_date: '2026-09-30',
+  closed_periods: [],
+  prior_entries: [
+    {
+      entry_id: 'ent_1',
+      posting_date: '2026-07-14',
+      memo: 'Invoice 1042',
+      total_debit: 120000,
+      total_credit: 120000,
+    },
+  ],
+  accepted_entries: [
+    {
+      entry_id: null,
+      posting_date: '2026-07-14',
+      memo: 'Invoice 1042',
+      total_debit: 150000,
+      total_credit: 150000,
+    },
+  ],
+  delta: [
+    {
+      element_id: 'elem_ar',
+      element_code: '1200',
+      element_name: 'Accounts Receivable',
+      prior_net: 120000,
+      accepted_net: 150000,
+      delta: 30000,
+    },
+    {
+      element_id: 'elem_rev',
+      element_code: '4000',
+      element_name: 'Service Revenue',
+      prior_net: -120000,
+      accepted_net: -150000,
+      delta: -30000,
+    },
+  ],
+  no_gl_effect: false,
+  restate_blockers: [],
+  unmapped_element_external_ids: [],
+  ...overrides,
+})
+
+const resolved = (overrides: Record<string, unknown> = {}) => ({
+  event_id: 'evt_invoice',
+  disposition: 'restate',
+  regenerated: { entry_ids: ['ent_2'] },
+  resolved_at: '2026-10-03T12:00:00Z',
+  resolved_by: 'user_1',
+  ...overrides,
+})
+
+const refusal = (detail: string) => new Error(JSON.stringify({ detail }))
+
+async function openFirst() {
+  render(<ChangedTransactionsPanel graphId="kg_books" />)
+  fireEvent.click(await screen.findByRole('button', { name: 'Review' }))
+  await screen.findByText('Difference by account')
+}
+
+describe('ChangedTransactionsPanel', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.spyOn(console, 'error').mockImplementation(() => {})
+    mockListEventBlocks.mockResolvedValue([event()])
+    mockPreviewReconcilingItem.mockResolvedValue(plan())
+    mockResolveReconcilingItem.mockResolvedValue(resolved())
+  })
+
+  it('asks only for the transactions changed at the source', async () => {
+    render(<ChangedTransactionsPanel graphId="kg_books" />)
+
+    await screen.findByText('qb-inv-1042')
+    expect(mockListEventBlocks).toHaveBeenCalledWith(
+      'kg_books',
+      expect.objectContaining({ isReconcilingItem: true })
+    )
+    expect(screen.getByText('Invoice 1042 to Northwind')).toBeInTheDocument()
+    expect(screen.getByText('invoice issued')).toBeInTheDocument()
+    expect(screen.getByText('$1,500.00')).toBeInTheDocument()
+  })
+
+  it('names where each change came from, and links to it there', async () => {
+    mockListEventBlocks.mockResolvedValue([
+      event({ externalUrl: 'https://qbo.example/txn/1042' }),
+      event({
+        id: 'evt_bank',
+        source: 'plaid',
+        externalId: 'bank-line-7',
+        occurredAt: '2026-06-02T00:00:00Z',
+      }),
+    ])
+    mockPreviewReconcilingItem.mockResolvedValue(
+      plan({ event_id: 'evt_bank', source: 'plaid' })
+    )
+    render(<ChangedTransactionsPanel graphId="kg_books" />)
+
+    expect(await screen.findByText('QuickBooks')).toBeInTheDocument()
+    expect(screen.getByText('Plaid')).toBeInTheDocument()
+    expect(screen.getByRole('link', { name: 'qb-inv-1042' })).toHaveAttribute(
+      'href',
+      'https://qbo.example/txn/1042'
+    )
+    // No link where the source gave none.
+    expect(
+      screen.queryByRole('link', { name: 'bank-line-7' })
+    ).not.toBeInTheDocument()
+
+    fireEvent.click(screen.getAllByRole('button', { name: 'Review' })[1])
+    expect(await screen.findByText('Plaid now')).toBeInTheDocument()
+  })
+
+  it('names a transaction by its type when it has no description', async () => {
+    mockListEventBlocks.mockResolvedValue([event({ description: null })])
+    render(<ChangedTransactionsPanel graphId="kg_books" />)
+
+    expect(await screen.findAllByText('invoice issued')).toHaveLength(1)
+  })
+
+  it('says so when nothing is waiting', async () => {
+    mockListEventBlocks.mockResolvedValue([])
+    render(<ChangedTransactionsPanel graphId="kg_books" />)
+
+    expect(
+      await screen.findByText('Nothing is waiting to be settled.')
+    ).toBeInTheDocument()
+  })
+
+  it('does not claim nothing is waiting when the list failed to load', async () => {
+    mockListEventBlocks.mockRejectedValue(new Error('boom'))
+    render(<ChangedTransactionsPanel graphId="kg_books" />)
+
+    expect(await screen.findByRole('alert')).toHaveTextContent(
+      'Failed to load changed transactions.'
+    )
+    expect(
+      screen.queryByText('Nothing is waiting to be settled.')
+    ).not.toBeInTheDocument()
+  })
+
+  it('shows what was posted, what the source says now, and the difference', async () => {
+    await openFirst()
+
+    expect(mockPreviewReconcilingItem).toHaveBeenCalledWith(
+      'kg_books',
+      'evt_invoice'
+    )
+    expect(screen.getByText('Accounts Receivable')).toBeInTheDocument()
+    expect(screen.getByText('$1,200.00 Dr')).toBeInTheDocument()
+    expect(screen.getByText('$1,500.00 Dr')).toBeInTheDocument()
+    expect(screen.getByText('$300.00 Dr')).toBeInTheDocument()
+    expect(screen.getByText('$300.00 Cr')).toBeInTheDocument()
+    // Looking at a change settles nothing.
+    expect(mockResolveReconcilingItem).not.toHaveBeenCalled()
+  })
+
+  it('starts on the treatment the plan recommends', async () => {
+    mockPreviewReconcilingItem.mockResolvedValue(
+      plan({ default_disposition: 'catch_up' })
+    )
+    await openFirst()
+
+    expect(screen.getByRole('radio', { name: /^Catch up/ })).toBeChecked()
+    expect(screen.getByRole('radio', { name: /^Restate/ })).not.toBeChecked()
+  })
+
+  it('settles with the chosen treatment and takes the row off the list', async () => {
+    await openFirst()
+    fireEvent.click(screen.getByRole('button', { name: 'Settle' }))
+
+    await waitFor(() =>
+      expect(mockResolveReconcilingItem).toHaveBeenCalledWith('kg_books', {
+        event_id: 'evt_invoice',
+        disposition: 'restate',
+      })
+    )
+    expect(await screen.findByRole('status')).toHaveTextContent(
+      'Restated. 1 entry was rebuilt to match the source.'
+    )
+    expect(screen.queryByText('qb-inv-1042')).not.toBeInTheDocument()
+  })
+
+  it('reports a catch-up as drafted, with its date', async () => {
+    mockResolveReconcilingItem.mockResolvedValue(
+      resolved({
+        disposition: 'catch_up',
+        regenerated: null,
+        catch_up: {
+          event_id: 'evt_catch_up',
+          posting_date: '2026-09-30',
+          status: 'draft',
+        },
+      })
+    )
+    await openFirst()
+    fireEvent.click(screen.getByRole('radio', { name: /^Catch up/ }))
+    fireEvent.click(screen.getByRole('button', { name: 'Settle' }))
+
+    expect(await screen.findByRole('status')).toHaveTextContent(
+      /A catch-up entry was drafted for .*2026/
+    )
+    expect(mockResolveReconcilingItem).toHaveBeenCalledWith('kg_books', {
+      event_id: 'evt_invoice',
+      disposition: 'catch_up',
+    })
+  })
+
+  it('will not offer a restate the ledger would refuse', async () => {
+    mockPreviewReconcilingItem.mockResolvedValue(
+      plan({
+        default_disposition: 'catch_up',
+        closed_periods: ['2026-07'],
+        restate_blockers: [
+          'posted in closed period(s) 2026-07 — reopen first, or catch up',
+        ],
+      })
+    )
+    await openFirst()
+
+    expect(screen.getByRole('radio', { name: /^Restate/ })).toBeDisabled()
+    expect(
+      screen.getByText(/Not available: posted in closed period\(s\) 2026-07/)
+    ).toBeInTheDocument()
+    expect(screen.getByRole('radio', { name: /^Catch up/ })).toBeChecked()
+    expect(screen.getByRole('button', { name: 'Settle' })).toBeEnabled()
+  })
+
+  it('leaves only "mark as handled" when the source uses an unmapped account', async () => {
+    mockPreviewReconcilingItem.mockResolvedValue(
+      plan({
+        default_disposition: 'catch_up',
+        unmapped_element_external_ids: ['qb-acct-88'],
+      })
+    )
+    await openFirst()
+
+    expect(screen.getByRole('radio', { name: /^Restate/ })).toBeDisabled()
+    expect(screen.getByRole('radio', { name: /^Catch up/ })).toBeDisabled()
+    expect(
+      screen.getByRole('radio', { name: /^Mark as handled/ })
+    ).toBeEnabled()
+    // The recommended treatment is one that cannot run, so nothing settles
+    // until another is chosen.
+    expect(screen.getByRole('button', { name: 'Settle' })).toBeDisabled()
+  })
+
+  it('requires a note to mark a change as handled, and sends it', async () => {
+    mockResolveReconcilingItem.mockResolvedValue(
+      resolved({ disposition: 'acknowledge', regenerated: null })
+    )
+    await openFirst()
+    fireEvent.click(screen.getByRole('radio', { name: /^Mark as handled/ }))
+
+    const settle = screen.getByRole('button', { name: 'Settle' })
+    expect(settle).toBeDisabled()
+
+    fireEvent.change(screen.getByLabelText(/Note/), {
+      target: { value: '  Booked by JE-88 in September  ' },
+    })
+    expect(settle).toBeEnabled()
+    fireEvent.click(settle)
+
+    await waitFor(() =>
+      expect(mockResolveReconcilingItem).toHaveBeenCalledWith('kg_books', {
+        event_id: 'evt_invoice',
+        disposition: 'acknowledge',
+        note: 'Booked by JE-88 in September',
+      })
+    )
+    expect(await screen.findByRole('status')).toHaveTextContent(
+      'Marked as handled. Nothing was posted.'
+    )
+  })
+
+  it('holds the other rows still while one is being settled', async () => {
+    mockListEventBlocks.mockResolvedValue([
+      event(),
+      event({ id: 'evt_bill', externalId: 'qb-bill-7' }),
+    ])
+    let finish: (value: unknown) => void = () => {}
+    mockResolveReconcilingItem.mockReturnValue(
+      new Promise((resolve) => {
+        finish = resolve
+      })
+    )
+    render(<ChangedTransactionsPanel graphId="kg_books" />)
+    fireEvent.click(
+      (await screen.findAllByRole('button', { name: 'Review' }))[0]
+    )
+    await screen.findByText('Difference by account')
+    fireEvent.click(screen.getByRole('button', { name: 'Settle' }))
+
+    await waitFor(() =>
+      expect(screen.getByRole('button', { name: 'Review' })).toBeDisabled()
+    )
+    expect(screen.getByRole('button', { name: 'Hide' })).toBeDisabled()
+
+    finish(resolved())
+    expect(await screen.findByRole('status')).toHaveTextContent('Restated.')
+    expect(screen.getByRole('button', { name: 'Review' })).toBeEnabled()
+  })
+
+  it('says a wording-only change moves no figures', async () => {
+    mockPreviewReconcilingItem.mockResolvedValue(
+      plan({ delta: [], no_gl_effect: true })
+    )
+    await openFirst()
+
+    expect(screen.getByText(/No account's balance changes/)).toBeInTheDocument()
+    expect(screen.getByText(/No figures change\./)).toBeInTheDocument()
+    expect(
+      screen.getByText(/This change moves no money, so nothing posts\./)
+    ).toBeInTheDocument()
+  })
+
+  it('keeps the change open and shows the refusal when settling fails', async () => {
+    mockResolveReconcilingItem.mockRejectedValue(
+      refusal('Event evt_invoice is being written by another process.')
+    )
+    await openFirst()
+    fireEvent.click(screen.getByRole('button', { name: 'Settle' }))
+
+    expect(await screen.findByRole('alert')).toHaveTextContent(
+      'Event evt_invoice is being written by another process.'
+    )
+    expect(screen.getByText('qb-inv-1042')).toBeInTheDocument()
+    expect(screen.getByRole('button', { name: 'Settle' })).toBeEnabled()
+  })
+
+  it('drops a change someone else already settled', async () => {
+    mockResolveReconcilingItem.mockRejectedValue(
+      refusal(
+        "Event evt_invoice is not a reconciling item — its payload matches the source system. It was already resolved as 'restate'."
+      )
+    )
+    await openFirst()
+    fireEvent.click(screen.getByRole('button', { name: 'Settle' }))
+
+    expect(await screen.findByRole('status')).toHaveTextContent(
+      'That change was already settled. Nothing was done.'
+    )
+    expect(screen.queryByText('qb-inv-1042')).not.toBeInTheDocument()
+  })
+
+  it('shows the newer figures when the source changed again mid-review', async () => {
+    mockResolveReconcilingItem.mockRejectedValue(
+      refusal(
+        'Event evt_invoice was re-flagged with a newer payload while this resolution was being prepared. Preview it again.'
+      )
+    )
+    await openFirst()
+    mockPreviewReconcilingItem.mockResolvedValue(
+      plan({
+        delta: [
+          {
+            element_id: 'elem_ar',
+            element_name: 'Accounts Receivable',
+            prior_net: 120000,
+            accepted_net: 175000,
+            delta: 55000,
+          },
+        ],
+      })
+    )
+    fireEvent.click(screen.getByRole('button', { name: 'Settle' }))
+
+    expect(await screen.findByText('$550.00 Dr')).toBeInTheDocument()
+    expect(
+      screen.getByText(/This transaction changed again at the source/)
+    ).toBeInTheDocument()
+    expect(mockPreviewReconcilingItem).toHaveBeenCalledTimes(2)
+    expect(screen.getByText('qb-inv-1042')).toBeInTheDocument()
+  })
+
+  it('ignores a preview that lands after another change was opened', async () => {
+    mockListEventBlocks.mockResolvedValue([
+      event(),
+      event({
+        id: 'evt_bill',
+        externalId: 'qb-bill-7',
+        occurredAt: '2026-06-02T00:00:00Z',
+      }),
+    ])
+    let releaseFirst: (value: unknown) => void = () => {}
+    mockPreviewReconcilingItem.mockImplementation((_graph, eventId) =>
+      eventId === 'evt_invoice'
+        ? new Promise((resolve) => {
+            releaseFirst = resolve
+          })
+        : Promise.resolve(
+            plan({
+              event_id: 'evt_bill',
+              delta: [
+                {
+                  element_id: 'elem_ap',
+                  element_name: 'Accounts Payable',
+                  prior_net: -5000,
+                  accepted_net: -9000,
+                  delta: -4000,
+                },
+              ],
+            })
+          )
+    )
+    render(<ChangedTransactionsPanel graphId="kg_books" />)
+
+    const [first, second] = await screen.findAllByRole('button', {
+      name: 'Review',
+    })
+    fireEvent.click(first)
+    fireEvent.click(second)
+    expect(await screen.findByText('Accounts Payable')).toBeInTheDocument()
+
+    releaseFirst(plan())
+    await waitFor(() =>
+      expect(screen.queryByText('Accounts Receivable')).not.toBeInTheDocument()
+    )
+  })
+})
diff --git a/src/app/(app)/ledger/close/__tests__/PeriodClosePanel.test.tsx b/src/app/(app)/ledger/close/__tests__/PeriodClosePanel.test.tsx
index 28ee88a..f32fb4a 100644
--- a/src/app/(app)/ledger/close/__tests__/PeriodClosePanel.test.tsx
+++ b/src/app/(app)/ledger/close/__tests__/PeriodClosePanel.test.tsx
@@ -312,6 +312,39 @@ describe('PeriodClosePanel — blockers name what is holding the close', () => {
     expect(screen.queryByText('reconciling_items')).not.toBeInTheDocument()
   })
 
+  it('leads from the reconciling-item blocker to the changes themselves', async () => {
+    mockGetFiscalCalendar.mockResolvedValue({
+      ...CALENDAR,
+      closeableNow: false,
+      blockers: ['reconciling_items'],
+      reconcilingItemCount: 3,
+    })
+    const onReviewChanges = vi.fn()
+    render(<PeriodClosePanel graphId="kg1" onReviewChanges={onReviewChanges} />)
+
+    const link = await screen.findByRole('button', {
+      name: 'Review changed transactions',
+    })
+    expect(link.parentElement).toHaveTextContent('3 holding this close.')
+    fireEvent.click(link)
+    expect(onReviewChanges).toHaveBeenCalledTimes(1)
+  })
+
+  it('offers no review link where nothing can open it', async () => {
+    mockGetFiscalCalendar.mockResolvedValue({
+      ...CALENDAR,
+      closeableNow: false,
+      blockers: ['reconciling_items'],
+      reconcilingItemCount: 3,
+    })
+    render(<PeriodClosePanel graphId="kg1" />)
+
+    await screen.findByText(/edited in QuickBooks after they were synced/)
+    expect(
+      screen.queryByRole('button', { name: 'Review changed transactions' })
+    ).not.toBeInTheDocument()
+  })
+
   it('offers Reopen only on the latest closed period', async () => {
     mockGetFiscalCalendar.mockResolvedValue(CALENDAR_AFTER)
     render(<PeriodClosePanel graphId="kg1" />)
diff --git a/src/app/(app)/ledger/close/__tests__/StructureSidebar.test.tsx b/src/app/(app)/ledger/close/__tests__/StructureSidebar.test.tsx
index f6f42e1..d783a2a 100644
--- a/src/app/(app)/ledger/close/__tests__/StructureSidebar.test.tsx
+++ b/src/app/(app)/ledger/close/__tests__/StructureSidebar.test.tsx
@@ -234,6 +234,52 @@ describe('StructureSidebar', () => {
     })
   })
 
+  it('selects and highlights the changed transactions entry', () => {
+    const onSelect = vi.fn()
+    const categories: ClosingBookCategory[] = [
+      {
+        label: 'Reconciliations',
+        items: [
+          {
+            id: 'reconciliations',
+            name: 'Reconciliations',
+            itemType: 'reconciliations',
+            blockType: null,
+            reportId: null,
+            status: null,
+          },
+          {
+            id: 'changed_transactions',
+            name: 'Changed transactions',
+            itemType: 'changed_transactions',
+            blockType: null,
+            reportId: null,
+            status: null,
+          },
+        ],
+      },
+    ]
+    const selected: SelectedItem = { type: 'changed_transactions' }
+    render(
+      <StructureSidebar
+        categories={categories}
+        selectedItem={selected}
+        onSelect={onSelect}
+        isLoading={false}
+      />
+    )
+
+    const entry = screen.getByText('Changed transactions').closest('button')
+    expect(entry?.className).toContain('font-medium')
+    // The worklist beside it is a different selection.
+    expect(
+      screen.getByRole('button', { name: 'Reconciliations' }).className
+    ).not.toContain('font-medium')
+
+    fireEvent.click(entry!)
+    expect(onSelect).toHaveBeenCalledWith({ type: 'changed_transactions' })
+  })
+
   it('collapses and expands the sidebar', () => {
     render(
       <StructureSidebar
diff --git a/src/app/(app)/ledger/close/__tests__/content.test.tsx b/src/app/(app)/ledger/close/__tests__/content.test.tsx
index edf614f..1609797 100644
--- a/src/app/(app)/ledger/close/__tests__/content.test.tsx
+++ b/src/app/(app)/ledger/close/__tests__/content.test.tsx
@@ -1,4 +1,4 @@
-import { render, screen, waitFor } from '@testing-library/react'
+import { fireEvent, render, screen, waitFor } from '@testing-library/react'
 import { describe, expect, it, vi } from 'vitest'
 
 const mockGetClosingBookStructures = vi.fn()
@@ -67,6 +67,9 @@ vi.mock('../components/StructureSidebar', () => ({
       {categories?.map((c: any) => (
         <div key={c.label} data-testid={`category-${c.label}`}>
           {c.label}: {c.items.length} items
+          {c.items.map((item: any) => (
+            <span key={item.id} data-testid={`item-${item.itemType}`} />
+          ))}
         </div>
       ))}
       {selectedItem && <div data-testid="selected">{selectedItem.type}</div>}
@@ -121,7 +124,17 @@ vi.mock('../components/AccountRollupsPanel', () => ({
 }))
 
 vi.mock('../components/PeriodClosePanel', () => ({
-  default: () => <div data-testid="period-close-panel" />,
+  default: ({ onReviewChanges }: any) => (
+    <div data-testid="period-close-panel">
+      <button onClick={onReviewChanges}>review changes</button>
+    </div>
+  ),
+}))
+
+vi.mock('../components/ChangedTransactionsPanel', () => ({
+  default: ({ graphId }: any) => (
+    <div data-testid="changed-transactions-panel">{graphId}</div>
+  ),
 }))
 
 vi.mock('../components/TrialBalancePanel', () => ({
@@ -340,6 +353,94 @@ describe('CloseContent', () => {
     expect(screen.queryByTestId('view-mode-toggle')).not.toBeInTheDocument()
   })
 
+  it('lists the changed transactions beside the reconciliations worklist', async () => {
+    const graph = makeGraph('kg_test')
+    mockUseGraphContext.mockReturnValue(makeGraphState([graph], 'kg_test'))
+    mockGetClosingBookStructures.mockResolvedValue({
+      categories: [
+        {
+          label: 'Period Close',
+          items: [
+            { id: 'pc', name: 'Current Period', itemType: 'period_close' },
+          ],
+        },
+        {
+          label: 'Reconciliations',
+          items: [
+            {
+              id: 'reconciliations',
+              name: 'Reconciliations',
+              itemType: 'reconciliations',
+            },
+          ],
+        },
+      ],
+      has_data: true,
+    })
+    mockGetEntity.mockResolvedValue(null)
+
+    render(<CloseContent />)
+
+    expect(
+      await screen.findByText('Reconciliations: 2 items')
+    ).toBeInTheDocument()
+    expect(screen.getByTestId('item-changed_transactions')).toBeInTheDocument()
+    // Only that category gains the entry.
+    expect(screen.getByText('Period Close: 1 items')).toBeInTheDocument()
+  })
+
+  it('adds no changed transactions entry before anything is posted', async () => {
+    const graph = makeGraph('kg_test')
+    mockUseGraphContext.mockReturnValue(makeGraphState([graph], 'kg_test'))
+    mockGetClosingBookStructures.mockResolvedValue({
+      categories: [
+        {
+          label: 'Period Close',
+          items: [
+            { id: 'pc', name: 'Current Period', itemType: 'period_close' },
+          ],
+        },
+      ],
+      has_data: false,
+    })
+    mockGetEntity.mockResolvedValue(null)
+
+    render(<CloseContent />)
+
+    await screen.findByTestId('period-close-panel')
+    expect(
+      screen.queryByTestId('item-changed_transactions')
+    ).not.toBeInTheDocument()
+  })
+
+  it('opens the changed transactions from the close hub', async () => {
+    const graph = makeGraph('kg_test')
+    mockUseGraphContext.mockReturnValue(makeGraphState([graph], 'kg_test'))
+    mockGetClosingBookStructures.mockResolvedValue({
+      categories: [
+        {
+          label: 'Period Close',
+          items: [
+            { id: 'pc', name: 'Current Period', itemType: 'period_close' },
+          ],
+        },
+      ],
+      has_data: true,
+    })
+    mockGetEntity.mockResolvedValue(null)
+
+    render(<CloseContent />)
+    fireEvent.click(await screen.findByText('review changes'))
+
+    expect(screen.getByTestId('changed-transactions-panel')).toHaveTextContent(
+      'kg_test'
+    )
+    expect(screen.getByTestId('selected')).toHaveTextContent(
+      'changed_transactions'
+    )
+    expect(screen.queryByTestId('period-close-panel')).not.toBeInTheDocument()
+  })
+
   it('calls API with correct graph ID', async () => {
     const graph = makeGraph('kg_mygraph123')
     mockUseGraphContext.mockReturnValue(
diff --git a/src/app/(app)/ledger/close/components/ChangedTransactionsPanel.tsx b/src/app/(app)/ledger/close/components/ChangedTransactionsPanel.tsx
new file mode 100644
index 0000000..38d25f8
--- /dev/null
+++ b/src/app/(app)/ledger/close/components/ChangedTransactionsPanel.tsx
@@ -0,0 +1,642 @@
+'use client'
+
+import DocsLink from '@/components/DocsLink'
+import { extractDetail } from '@/lib/ledger/errors'
+import { formatAmount, formatDate } from '@/lib/ledger/formatters'
+import type {
+  ReconcilingItemPlan,
+  ResolveReconcilingItemResponse,
+} from '@robosystems/client'
+import type { LedgerEventBlock } from '@robosystems/client/clients'
+import { clients, LoadingState } from '@robosystems/core'
+import {
+  Button,
+  Label,
+  Spinner,
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeadCell,
+  TableRow,
+  Textarea,
+} from 'flowbite-react'
+import type { FC } from 'react'
+import { Fragment, useCallback, useEffect, useRef, useState } from 'react'
+import { HiCheckCircle, HiExclamationCircle } from 'react-icons/hi'
+
+type Treatment = 'restate' | 'catch_up' | 'acknowledge'
+
+const CHANGES_LIMIT = 200
+
+// A sync from the books or an amended bank line can both flag a change.
+const SOURCE_NAMES: Record<string, string> = {
+  quickbooks: 'QuickBooks',
+  plaid: 'Plaid',
+  mercury: 'Mercury',
+}
+
+function sourceName(source: string | null | undefined): string {
+  return (source && SOURCE_NAMES[source]) || 'The source'
+}
+
+// ── Helpers ────────────────────────────────────────────────────────────
+
+/** The API's own words for a refusal, or a fallback when there are none. */
+const describeError = (err: unknown, fallback: string): string =>
+  err instanceof Error ? extractDetail(err.message) : fallback
+
+/** A signed amount in minor units, debit-positive, as the API reports it. */
+function netAmount(cents: number, currency: string | null | undefined) {
+  if (cents === 0) return formatAmount(0, currency)
+  return `${formatAmount(Math.abs(cents), currency)} ${cents > 0 ? 'Dr' : 'Cr'}`
+}
+
+function describeOutcome(result: ResolveReconcilingItemResponse): string {
+  if (result.disposition === 'restate') {
+    const rebuilt = result.regenerated?.entry_ids?.length ?? 0
+    return `Restated. ${rebuilt} ${rebuilt === 1 ? 'entry was' : 'entries were'} rebuilt to match the source.`
+  }
+  if (result.disposition === 'catch_up') {
+    if (!result.catch_up) {
+      return 'Settled. The change moved no money, so nothing was posted.'
+    }
+    const verb = result.catch_up.status === 'posted' ? 'posted' : 'drafted'
+    return `Settled. A catch-up entry was ${verb} for ${formatDate(result.catch_up.posting_date)}.`
+  }
+  return 'Marked as handled. Nothing was posted.'
+}
+
+/** Why a treatment cannot be chosen for this change, or null when it can. */
+function blockedReason(
+  treatment: Treatment,
+  plan: ReconcilingItemPlan
+): string | null {
+  const unmapped = plan.unmapped_element_external_ids ?? []
+  if (treatment !== 'acknowledge' && unmapped.length > 0) {
+    return 'The source now uses an account this ledger has not mapped. Sync and map it first.'
+  }
+  if (treatment === 'restate') {
+    const blockers = plan.restate_blockers ?? []
+    if (blockers.length > 0) return `${blockers.join('; ')}.`
+  }
+  return null
+}
+
+// ── Component ──────────────────────────────────────────────────────────
+
+interface ChangedTransactionsPanelProps {
+  graphId: string
+}
+
+/**
+ * Transactions edited in the source system after they were posted. Each one
+ * is shown as posted against as it stands now, and settled one of three ways.
+ */
+const ChangedTransactionsPanel: FC<ChangedTransactionsPanelProps> = ({
+  graphId,
+}) => {
+  const [items, setItems] = useState<LedgerEventBlock[] | null>(null)
+  const [error, setError] = useState<string | null>(null)
+  const [truncated, setTruncated] = useState(false)
+
+  const [selectedId, setSelectedId] = useState<string | null>(null)
+  const [plan, setPlan] = useState<ReconcilingItemPlan | null>(null)
+  const [planError, setPlanError] = useState<string | null>(null)
+
+  const [treatment, setTreatment] = useState<Treatment>('restate')
+  const [note, setNote] = useState('')
+  const [isSettling, setIsSettling] = useState(false)
+  const [settleError, setSettleError] = useState<string | null>(null)
+  const [notice, setNotice] = useState<string | null>(null)
+  const [outcome, setOutcome] = useState<string | null>(null)
+
+  // Sequence guards: a preview that lands after another row was opened, and
+  // anything that lands after the graph changed, is dropped.
+  const planSeq = useRef(0)
+  const graphSeq = useRef(0)
+
+  useEffect(() => {
+    let cancelled = false
+    planSeq.current += 1
+    graphSeq.current += 1
+    setItems(null)
+    setTruncated(false)
+    setSelectedId(null)
+    setPlan(null)
+    setOutcome(null)
+    setError(null)
+    void (async () => {
+      try {
+        const list = await clients.ledger.listEventBlocks(graphId, {
+          isReconcilingItem: true,
+          limit: CHANGES_LIMIT,
+        })
+        if (cancelled) return
+        list.sort(
+          (a, b) =>
+            new Date(b.occurredAt).getTime() - new Date(a.occurredAt).getTime()
+        )
+        setItems(list)
+        setTruncated(list.length >= CHANGES_LIMIT)
+      } catch (err) {
+        if (cancelled) return
+        console.error('Error loading changed transactions:', err)
+        setError('Failed to load changed transactions.')
+        setItems([])
+      }
+    })()
+    return () => {
+      cancelled = true
+    }
+  }, [graphId])
+
+  const openItem = useCallback(
+    async (eventId: string) => {
+      const seq = ++planSeq.current
+      setSelectedId(eventId)
+      setPlan(null)
+      setPlanError(null)
+      setSettleError(null)
+      setNotice(null)
+      setNote('')
+      try {
+        const result = await clients.ledger.previewReconcilingItem(
+          graphId,
+          eventId
+        )
+        if (seq !== planSeq.current) return
+        setPlan(result)
+        setTreatment(result.default_disposition)
+      } catch (err) {
+        if (seq !== planSeq.current) return
+        console.error('Error previewing changed transaction:', err)
+        setPlanError(describeError(err, 'Failed to load this change.'))
+      }
+    },
+    [graphId]
+  )
+
+  const closeItem = useCallback(() => {
+    planSeq.current += 1
+    setSelectedId(null)
+    setPlan(null)
+    setPlanError(null)
+    setSettleError(null)
+    setNotice(null)
+  }, [])
+
+  const handleSettle = useCallback(async () => {
+    if (!selectedId || !plan) return
+    const trimmed = note.trim()
+    const seq = graphSeq.current
+    try {
+      setIsSettling(true)
+      setSettleError(null)
+      const result = await clients.ledger.resolveReconcilingItem(graphId, {
+        event_id: selectedId,
+        disposition: treatment,
+        ...(trimmed ? { note: trimmed } : {}),
+      })
+      if (seq !== graphSeq.current) return
+      setOutcome(describeOutcome(result))
+      setItems((current) =>
+        current ? current.filter((item) => item.id !== selectedId) : current
+      )
+      closeItem()
+    } catch (err) {
+      console.error('Error settling changed transaction:', err)
+      if (seq !== graphSeq.current) return
+      const detail = describeError(err, 'The change was not settled.')
+      if (detail.includes('not a reconciling item')) {
+        // Settled from somewhere else since the list loaded.
+        setItems((current) =>
+          current ? current.filter((item) => item.id !== selectedId) : current
+        )
+        closeItem()
+        setOutcome('That change was already settled. Nothing was done.')
+      } else if (detail.includes('re-flagged')) {
+        // The source changed again; what was on screen is no longer the plan.
+        await openItem(selectedId)
+        setNotice(
+          'This transaction changed again at the source while it was open. These are the latest figures; nothing was settled.'
+        )
+      } else {
+        setSettleError(detail)
+      }
+    } finally {
+      setIsSettling(false)
+    }
+  }, [graphId, selectedId, plan, treatment, note, closeItem, openItem])
+
+  const selected = items?.find((item) => item.id === selectedId) ?? null
+
+  return (
+    <div className="space-y-4">
+      <div>
+        <h2 className="text-lg font-semibold text-gray-900 dark:text-white">
+          Changed transactions
+        </h2>
+        <p className="text-sm text-gray-500 dark:text-gray-400">
+          Transactions that changed in QuickBooks or at the bank after
+          RoboLedger recorded them. A close will not run over one nobody has
+          settled. <DocsLink href="/docs/changes-after-sync" />
+        </p>
+      </div>
+
+      {error && (
+        <div
+          role="alert"
+          className="flex items-start gap-2 rounded-lg border border-red-300 bg-red-50 p-3 text-sm text-red-700 dark:border-red-700 dark:bg-red-900/30 dark:text-red-300"
+        >
+          <HiExclamationCircle className="mt-0.5 h-4 w-4 shrink-0" />
+          <span>{error}</span>
+        </div>
+      )}
+
+      {outcome && (
+        <div
+          role="status"
+          className="flex items-start gap-2 rounded-lg border border-green-300 bg-green-50 p-3 text-sm text-green-800 dark:border-green-700 dark:bg-green-900/30 dark:text-green-200"
+        >
+          <HiCheckCircle className="mt-0.5 h-4 w-4 shrink-0" />
+          <span>{outcome}</span>
+        </div>
+      )}
+
+      {items === null ? (
+        <LoadingState size="lg" className="py-16" />
+      ) : items.length === 0 ? (
+        !error && (
+          <div className="rounded-lg border border-dashed border-gray-300 p-8 text-center text-sm text-gray-500 dark:border-gray-600 dark:text-gray-400">
+            <p className="font-medium text-gray-700 dark:text-gray-200">
+              Nothing is waiting to be settled.
+            </p>
+            <p className="mx-auto mt-2 max-w-xl">
+              When a transaction changes in QuickBooks or at the bank after
+              RoboLedger recorded it, the next sync flags it here instead of
+              overwriting what was posted.
+            </p>
+          </div>
+        )
+      ) : (
+        <Table>
+          <TableHead>
+            <tr>
+              <TableHeadCell>Date</TableHeadCell>
+              <TableHeadCell>Transaction</TableHeadCell>
+              <TableHeadCell>Changed in</TableHeadCell>
+              <TableHeadCell>Reference</TableHeadCell>
+              <TableHeadCell className="text-right">Amount</TableHeadCell>
+              <TableHeadCell>
+                <span className="sr-only">Actions</span>
+              </TableHeadCell>
+            </tr>
+          </TableHead>
+          <TableBody>
+            {items.map((item) => {
+              const isOpen = item.id === selectedId
+              return (
+                <Fragment key={item.id}>
+                  <TableRow>
+                    <TableCell className="whitespace-nowrap text-gray-900 dark:text-white">
+                      {formatDate(item.occurredAt)}
+                    </TableCell>
+                    <TableCell>
+                      <span className="block text-gray-900 dark:text-white">
+                        {item.description ?? item.eventType.replace(/_/g, ' ')}
+                      </span>
+                      {item.description ? (
+                        <span className="block text-xs text-gray-500 dark:text-gray-400">
+                          {item.eventType.replace(/_/g, ' ')}
+                        </span>
+                      ) : null}
+                    </TableCell>
+                    <TableCell className="whitespace-nowrap">
+                      {sourceName(item.source)}
+                    </TableCell>
+                    <TableCell className="font-mono text-xs">
+                      {item.externalUrl && item.externalId ? (
+                        <a
+                          href={item.externalUrl}
+                          target="_blank"
+                          rel="noopener noreferrer"
+                          className="text-primary-600 dark:text-primary-400 underline"
+                        >
+                          {item.externalId}
+                        </a>
+                      ) : (
+                        (item.externalId ?? '—')
+                      )}
+                    </TableCell>
+                    <TableCell className="text-right font-mono">
+                      {formatAmount(item.amount ?? null, item.currency)}
+                    </TableCell>
+                    <TableCell className="text-right">
+                      <Button
+                        size="xs"
+                        color="light"
+                        disabled={isSettling}
+                        onClick={() =>
+                          isOpen ? closeItem() : openItem(item.id)
+                        }
+                      >
+                        {isOpen ? 'Hide' : 'Review'}
+                      </Button>
+                    </TableCell>
+                  </TableRow>
+                  {isOpen && (
+                    <TableRow>
+                      <TableCell
+                        colSpan={6}
+                        className="bg-gray-50 dark:bg-gray-900/40"
+                      >
+                        {planError ? (
+                          <p
+                            role="alert"
+                            className="text-sm text-red-600 dark:text-red-400"
+                          >
+                            {planError}
+                          </p>
+                        ) : !plan ? (
+                          <LoadingState size="md" className="py-6" />
+                        ) : (
+                          <ChangeDetail
+                            plan={plan}
+                            currency={selected?.currency}
+                            treatment={treatment}
+                            onTreatment={setTreatment}
+                            note={note}
+                            onNote={setNote}
+                            isSettling={isSettling}
+                            settleError={settleError}
+                            notice={notice}
+                            onSettle={handleSettle}
+                          />
+                        )}
+                      </TableCell>
+                    </TableRow>
+                  )}
+                </Fragment>
+              )
+            })}
+          </TableBody>
+        </Table>
+      )}
+
+      {truncated && (
+        <p className="text-xs text-gray-500 dark:text-gray-400">
+          Showing the {CHANGES_LIMIT} most recent. Settle these to see the rest.
+        </p>
+      )}
+    </div>
+  )
+}
+
+// ── Detail ─────────────────────────────────────────────────────────────
+
+interface ChangeDetailProps {
+  plan: ReconcilingItemPlan
+  currency: string | null | undefined
+  treatment: Treatment
+  onTreatment: (treatment: Treatment) => void
+  note: string
+  onNote: (note: string) => void
+  isSettling: boolean
+  settleError: string | null
+  notice: string | null
+  onSettle: () => void
+}
+
+const ChangeDetail: FC<ChangeDetailProps> = ({
+  plan,
+  currency,
+  treatment,
+  onTreatment,
+  note,
+  onNote,
+  isSettling,
+  settleError,
+  notice,
+  onSettle,
+}) => {
+  const delta = plan.delta ?? []
+  const closedPeriods = plan.closed_periods ?? []
+  const catchUpDate = plan.default_posting_date
+    ? formatDate(plan.default_posting_date)
+    : null
+
+  const options: { value: Treatment; label: string; detail: string }[] = [
+    {
+      value: 'restate',
+      label: 'Restate',
+      detail: plan.no_gl_effect
+        ? 'Rebuild the entries so they carry the new wording. No figures change.'
+        : "Rebuild the entries to match the source, in the month the transaction belongs to. That month's figures change.",
+    },
+    {
+      value: 'catch_up',
+      label: 'Catch up',
+      detail: plan.no_gl_effect
+        ? 'The original month stays as it was. This change moves no money, so nothing posts.'
+        : `The original month stays as it was. The difference is drafted as one entry${catchUpDate ? ` on ${catchUpDate}` : ' in an open month'} and posts when that period closes. It stays in RoboLedger.`,
+    },
+    {
+      value: 'acknowledge',
+      label: 'Mark as handled',
+      detail:
+        'You already booked the difference yourself. Nothing posts; your note is the record.',
+    },
+  ]
+
+  const chosenBlocked = blockedReason(treatment, plan)
+  const needsNote = treatment === 'acknowledge' && !note.trim()
+
+  return (
+    <div className="space-y-4 py-2 text-sm">
+      {notice && (
+        <p role="status" className="text-yellow-800 dark:text-yellow-200">
+          {notice}
+        </p>
+      )}
+
+      <div className="grid gap-4 md:grid-cols-2">
+        <EntryList
+          title="Posted by RoboLedger"
+          entries={plan.prior_entries ?? []}
+          currency={currency}
+        />
+        <EntryList
+          title={`${sourceName(plan.source)} now`}
+          entries={plan.accepted_entries ?? []}
+          currency={currency}
+        />
+      </div>
+
+      <div>
+        <h3 className="mb-1 font-medium text-gray-900 dark:text-white">
+          Difference by account
+        </h3>
+        {delta.length === 0 ? (
+          <p className="text-gray-500 dark:text-gray-400">
+            No account&apos;s balance changes. The edit was to a memo or a
+            reference.
+          </p>
+        ) : (
+          <table className="w-full text-left">
+            <thead className="text-xs text-gray-500 uppercase dark:text-gray-400">
+              <tr>
+                <th className="py-1 pr-4 font-medium">Account</th>
+                <th className="py-1 pr-4 text-right font-medium">Posted</th>
+                <th className="py-1 pr-4 text-right font-medium">Now</th>
+                <th className="py-1 text-right font-medium">Difference</th>
+              </tr>
+            </thead>
+            <tbody className="text-gray-900 dark:text-white">
+              {delta.map((line, index) => (
+                <tr key={line.element_id ?? line.element_external_id ?? index}>
+                  <td className="py-1 pr-4">
+                    {line.element_name ??
+                      `Unmapped account ${line.element_external_id ?? ''}`.trim()}
+                    {line.element_code ? (
+                      <span className="ml-2 font-mono text-xs text-gray-500 dark:text-gray-400">
+                        {line.element_code}
+                      </span>
+                    ) : null}
+                  </td>
+                  <td className="py-1 pr-4 text-right font-mono">
+                    {netAmount(line.prior_net, currency)}
+                  </td>
+                  <td className="py-1 pr-4 text-right font-mono">
+                    {netAmount(line.accepted_net, currency)}
+                  </td>
+                  <td className="py-1 text-right font-mono font-medium">
+                    {netAmount(line.delta, currency)}
+                  </td>
+                </tr>
+              ))}
+            </tbody>
+          </table>
+        )}
+      </div>
+
+      {closedPeriods.length > 0 && (
+        <p className="text-yellow-800 dark:text-yellow-200">
+          The posted entries sit in{' '}
+          {closedPeriods.length === 1 ? 'a closed period' : 'closed periods'}:{' '}
+          {closedPeriods.join(', ')}.
+        </p>
+      )}
+
+      <fieldset className="space-y-2">
+        <legend className="mb-1 font-medium text-gray-900 dark:text-white">
+          How to settle it
+        </legend>
+        {options.map((option) => {
+          const blocked = blockedReason(option.value, plan)
+          return (
+            <label
+              key={option.value}
+              className={`flex items-start gap-3 rounded-lg border p-3 ${
+                treatment === option.value
+                  ? 'border-primary-500 bg-primary-50 dark:border-primary-400 dark:bg-primary-900/20'
+                  : 'border-gray-200 dark:border-gray-700'
+              } ${blocked ? 'opacity-60' : 'cursor-pointer'}`}
+            >
+              <input
+                type="radio"
+                name="treatment"
+                className="mt-1"
+                value={option.value}
+                checked={treatment === option.value}
+                disabled={Boolean(blocked) || isSettling}
+                onChange={() => onTreatment(option.value)}
+              />
+              <span>
+                <span className="font-medium text-gray-900 dark:text-white">
+                  {option.label}
+                </span>
+                <span className="block text-gray-600 dark:text-gray-300">
+                  {option.detail}
+                </span>
+                {blocked && (
+                  <span className="mt-1 block text-yellow-800 dark:text-yellow-200">
+                    Not available: {blocked}
+                  </span>
+                )}
+              </span>
+            </label>
+          )
+        })}
+      </fieldset>
+
+      <div>
+        <Label htmlFor="settle-note" className="text-sm font-medium">
+          Note{treatment === 'acknowledge' ? ' (required)' : ' (optional)'}
+        </Label>
+        <Textarea
+          id="settle-note"
+          rows={2}
+          value={note}
+          onChange={(e) => onNote(e.target.value)}
+          placeholder={
+            treatment === 'acknowledge'
+              ? 'How the difference was handled, and which entry covered it'
+              : 'Why this treatment'
+          }
+        />
+      </div>
+
+      {settleError && (
+        <p role="alert" className="text-red-600 dark:text-red-400">
+          {settleError}
+        </p>
+      )}
+
+      <Button
+        size="sm"
+        color="primary"
+        disabled={isSettling || Boolean(chosenBlocked) || needsNote}
+        onClick={onSettle}
+      >
+        {isSettling ? <Spinner size="sm" className="mr-2 text-white" /> : null}
+        Settle
+      </Button>
+    </div>
+  )
+}
+
+interface EntryListProps {
+  title: string
+  entries: NonNullable<ReconcilingItemPlan['prior_entries']>
+  currency: string | null | undefined
+}
+
+const EntryList: FC<EntryListProps> = ({ title, entries, currency }) => (
+  <div>
+    <h3 className="mb-1 font-medium text-gray-900 dark:text-white">{title}</h3>
+    {entries.length === 0 ? (
+      <p className="text-gray-500 dark:text-gray-400">No entries.</p>
+    ) : (
+      <ul className="space-y-1 text-gray-700 dark:text-gray-200">
+        {entries.map((entry, index) => (
+          <li key={entry.entry_id ?? entry.external_id ?? index}>
+            <span className="whitespace-nowrap">
+              {entry.posting_date ? formatDate(entry.posting_date) : 'No date'}
+            </span>
+            <span className="ml-2 font-mono">
+              {formatAmount(entry.total_debit ?? 0, currency)}
+            </span>
+            {entry.memo ? (
+              <span className="ml-2 text-gray-500 dark:text-gray-400">
+                {entry.memo}
+              </span>
+            ) : null}
+          </li>
+        ))}
+      </ul>
+    )}
+  </div>
+)
+
+export default ChangedTransactionsPanel
diff --git a/src/app/(app)/ledger/close/components/PeriodClosePanel.tsx b/src/app/(app)/ledger/close/components/PeriodClosePanel.tsx
index 1cde5f3..3f17daa 100644
--- a/src/app/(app)/ledger/close/components/PeriodClosePanel.tsx
+++ b/src/app/(app)/ledger/close/components/PeriodClosePanel.tsx
@@ -148,6 +148,8 @@ function obligationDetailFor(
 interface PeriodClosePanelProps {
   graphId: string
   onEntryCreated?: () => void
+  /** Opens the changed transactions the close is waiting on. */
+  onReviewChanges?: () => void
 }
 
 // Compute period bounds (YYYY-MM-DD) for a given YYYY-MM period name.
@@ -172,6 +174,7 @@ function formatPeriod(period: string | null): string {
 const PeriodClosePanel: FC<PeriodClosePanelProps> = ({
   graphId,
   onEntryCreated,
+  onReviewChanges,
 }) => {
   // ── State ────────────────────────────────────────────────────────────
   const [calendar, setCalendar] = useState<LedgerFiscalCalendar | null>(null)
@@ -530,7 +533,11 @@ const PeriodClosePanel: FC<PeriodClosePanelProps> = ({
         />
       )}
 
-      <CalendarSummary calendar={calendar} onRefresh={loadCalendar} />
+      <CalendarSummary
+        calendar={calendar}
+        onRefresh={loadCalendar}
+        onReviewChanges={onReviewChanges}
+      />
 
       {/* Period selector */}
       <div className="flex flex-wrap items-center gap-4 border-b border-gray-200 pb-4 dark:border-gray-700">
@@ -820,9 +827,14 @@ const CloseSuccessCard: FC<CloseSuccessCardProps> = ({ result, onDismiss }) => {
 interface CalendarSummaryProps {
   calendar: LedgerFiscalCalendar
   onRefresh: () => void
+  onReviewChanges?: () => void
 }
 
-const CalendarSummary: FC<CalendarSummaryProps> = ({ calendar, onRefresh }) => {
+const CalendarSummary: FC<CalendarSummaryProps> = ({
+  calendar,
+  onRefresh,
+  onReviewChanges,
+}) => {
   return (
     <Card>
       <div className="flex flex-wrap items-start justify-between gap-4">
@@ -879,6 +891,18 @@ const CalendarSummary: FC<CalendarSummaryProps> = ({ calendar, onRefresh }) => {
               <li key={code}>
                 {BLOCKER_MESSAGES[code] ?? code}
                 {obligationDetailFor(code, calendar)}
+                {code === 'reconciling_items' && onReviewChanges && (
+                  <div className="mt-1 text-xs">
+                    {calendar.reconcilingItemCount} holding this close.{' '}
+                    <button
+                      type="button"
+                      onClick={onReviewChanges}
+                      className="font-medium underline"
+                    >
+                      Review changed transactions
+                    </button>
+                  </div>
+                )}
               </li>
             ))}
           </ul>
diff --git a/src/app/(app)/ledger/close/components/StructureSidebar.tsx b/src/app/(app)/ledger/close/components/StructureSidebar.tsx
index 2eb7957..4f34b4d 100644
--- a/src/app/(app)/ledger/close/components/StructureSidebar.tsx
+++ b/src/app/(app)/ledger/close/components/StructureSidebar.tsx
@@ -20,6 +20,7 @@ export type SelectedItem =
   | { type: 'account_rollups'; mappingId: string; name: string }
   | { type: 'trial_balance' }
   | { type: 'reconciliations' }
+  | { type: 'changed_transactions' }
   | { type: 'period_close' }
 
 // ── Helpers ────────────────────────────────────────────────────────────
@@ -46,6 +47,8 @@ function itemToSelected(item: ClosingBookItem): SelectedItem {
       return { type: 'trial_balance' }
     case 'reconciliations':
       return { type: 'reconciliations' }
+    case 'changed_transactions':
+      return { type: 'changed_transactions' }
     case 'period_close':
       return { type: 'period_close' }
     default:
@@ -74,6 +77,8 @@ function isActive(
       return item.itemType === 'trial_balance'
     case 'reconciliations':
       return item.itemType === 'reconciliations'
+    case 'changed_transactions':
+      return item.itemType === 'changed_transactions'
     case 'period_close':
       return item.itemType === 'period_close'
   }
diff --git a/src/app/(app)/ledger/close/content.tsx b/src/app/(app)/ledger/close/content.tsx
index 74747c1..432112a 100644
--- a/src/app/(app)/ledger/close/content.tsx
+++ b/src/app/(app)/ledger/close/content.tsx
@@ -13,10 +13,11 @@ import {
 } from '@robosystems/core'
 import { Card } from 'flowbite-react'
 import type { FC } from 'react'
-import { useCallback, useEffect, useState } from 'react'
+import { useCallback, useEffect, useMemo, useState } from 'react'
 import { HiExclamationCircle } from 'react-icons/hi'
 import { TbBook2 } from 'react-icons/tb'
 import AccountRollupsPanel from './components/AccountRollupsPanel'
+import ChangedTransactionsPanel from './components/ChangedTransactionsPanel'
 import { NewScheduleModal } from './components/NewScheduleModal'
 import PeriodClosePanel from './components/PeriodClosePanel'
 import ReconciliationsPanel from './components/ReconciliationsPanel'
@@ -35,8 +36,8 @@ type ClosingBookCategories = LedgerClosingBookStructures['categories']
  * Whether a selection still refers to something in the freshly loaded
  * structures. Statements, schedules and rollups are identified by an id that is
  * per-graph, so a selection made before a graph switch must not be carried
- * over; the hub, the trial balance and the reconciliations worklist are not
- * tied to an id.
+ * over; the hub, the trial balance, the reconciliations worklist and the
+ * changed transactions are not tied to an id.
  */
 function selectionExists(
   selected: SelectedItem,
@@ -45,7 +46,8 @@ function selectionExists(
   if (
     selected.type === 'period_close' ||
     selected.type === 'trial_balance' ||
-    selected.type === 'reconciliations'
+    selected.type === 'reconciliations' ||
+    selected.type === 'changed_transactions'
   ) {
     return true
   }
@@ -58,6 +60,35 @@ function selectionExists(
   )
 }
 
+const RECONCILIATIONS_LABEL = 'Reconciliations'
+
+/**
+ * The server lists the reconciliations worklist. The transactions changed at
+ * the source sit beside it, and that entry is added here.
+ */
+function withChangedTransactions(
+  categories: ClosingBookCategories
+): ClosingBookCategories {
+  return categories.map((category) =>
+    category.label === RECONCILIATIONS_LABEL
+      ? {
+          ...category,
+          items: [
+            ...category.items,
+            {
+              id: 'changed_transactions',
+              name: 'Changed transactions',
+              itemType: 'changed_transactions',
+              blockType: null,
+              reportId: null,
+              status: null,
+            },
+          ],
+        }
+      : category
+  )
+}
+
 const CloseContent: FC = function () {
   const { state: graphState } = useGraphContext()
 
@@ -159,6 +190,11 @@ const CloseContent: FC = function () {
     loadSidebarData()
   }, [loadSidebarData])
 
+  const sidebarCategories = useMemo(
+    () => withChangedTransactions(categories),
+    [categories]
+  )
+
   // No qualifying graph
   if (!currentGraph && !graphState.isLoading) {
     return (
@@ -215,7 +251,7 @@ const CloseContent: FC = function () {
       <div className="flex flex-col gap-6 lg:flex-row">
         {/* Structure Sidebar */}
         <StructureSidebar
-          categories={categories}
+          categories={sidebarCategories}
           selectedItem={selectedItem}
           onSelect={setSelectedItem}
           isLoading={isSidebarLoading}
@@ -258,10 +294,15 @@ const CloseContent: FC = function () {
               <TrialBalancePanel graphId={currentGraph.graphId} />
             ) : selectedItem.type === 'reconciliations' && currentGraph ? (
               <ReconciliationsPanel graphId={currentGraph.graphId} />
+            ) : selectedItem.type === 'changed_transactions' && currentGraph ? (
+              <ChangedTransactionsPanel graphId={currentGraph.graphId} />
             ) : selectedItem.type === 'period_close' && currentGraph ? (
               <PeriodClosePanel
                 graphId={currentGraph.graphId}
                 onEntryCreated={handleEntryCreated}
+                onReviewChanges={() =>
+                  setSelectedItem({ type: 'changed_transactions' })
+                }
               />
             ) : null}
           </Card>