fix(ui): restore prompt rail scroll tracking

apps/desktop/e2e/prompt-rail.spec.ts

@@ -131,6 +131,102 @@ function notifyTranscriptScrolled(page: Page): Promise<void> {
   });
 }
 
+interface ActivePromptRailSnapshot {
+  currentIds: string[];
+  expectedId: string | null;
+  sourceTurnId: string | null;
+}
+
+async function activePromptRailSnapshot(page: Page): Promise<ActivePromptRailSnapshot> {
+  return page.evaluate(async ({ promptCount }) => {
+    const root = document.querySelector<HTMLElement>('[data-chat-scroll-container="true"]');
+    if (!root) throw new Error('the chat scroll container is missing');
+    const ticks = [...document.querySelectorAll<HTMLElement>('.maka-prompt-rail-tick')];
+    const currentIds = ticks
+      .filter((tick) => tick.getAttribute('aria-current') === 'true')
+      .map((tick) => tick.dataset.promptTurnId ?? '');
+    const rootBounds = root.getBoundingClientRect();
+    const atEnd = root.scrollHeight - root.scrollTop - root.clientHeight <= 2;
+    const turns = [...root.querySelectorAll<HTMLElement>('[data-transcript-turn-id]')]
+      .map((turn) => ({
+        element: turn,
+        id: turn.dataset.transcriptTurnId ?? '',
+        index: Number(turn.dataset.transcriptTurnId?.split('-').at(-1)) - 1,
+      }))
+      .filter((turn) => turn.id.length > 0 && Number.isFinite(turn.index));
+    const readingBandTurns = turns
+      .filter(({ element }) => {
+        const bounds = element.getBoundingClientRect();
+        return bounds.bottom > rootBounds.top
+          && bounds.top < rootBounds.top + rootBounds.height * 0.34;
+      })
+      .sort((left, right) => left.index - right.index);
+    const scrollportTurns = turns
+      .filter(({ element }) => {
+        const bounds = element.getBoundingClientRect();
+        return bounds.bottom > rootBounds.top && bounds.top < rootBounds.bottom;
+      })
+      .sort((left, right) => left.index - right.index);
+    const sourceTurn = atEnd
+      ? turns.reduce<typeof turns[number] | null>(
+        (latest, turn) => latest === null || turn.index > latest.index ? turn : latest,
+        null,
+      )
+      : readingBandTurns[0] ?? scrollportTurns[0] ?? null;
+    const expectedRailIndex = sourceTurn === null || ticks.length === 0
+      ? null
+      : Math.round(
+        sourceTurn.index * (ticks.length - 1) / (promptCount - 1),
+      );
+    const expectedId = expectedRailIndex === null
+      ? null
+      : ticks[expectedRailIndex]?.dataset.promptTurnId ?? null;
+    return {
+      currentIds,
+      expectedId,
+      sourceTurnId: sourceTurn?.id ?? null,
+    };
+  }, { promptCount: PROMPT_RAIL_PROMPT_COUNT });
+}
+
+async function expectPromptRailMatchesReadingPosition(page: Page): Promise<void> {
+  let lastSnapshot: ActivePromptRailSnapshot | null = null;
+  try {
+    await expect.poll(async () => {
+      lastSnapshot = await activePromptRailSnapshot(page);
+      return lastSnapshot.expectedId !== null
+        && lastSnapshot.currentIds.length === 1
+        && lastSnapshot.currentIds[0] === lastSnapshot.expectedId;
+    }, { message: 'the one current tick maps from the Turn being read' }).toBe(true);
+  } catch {
+    throw new Error(`the prompt rail did not settle on the reading position: ${JSON.stringify(lastSnapshot)}`);
+  }
+  const snapshot = await activePromptRailSnapshot(page);
+  expect(snapshot.expectedId, `no visible Turn in ${JSON.stringify(snapshot)}`).not.toBeNull();
+  expect(snapshot.currentIds).toEqual([snapshot.expectedId]);
+}
+
+async function scrollTranscriptThroughHistory(page: Page): Promise<void> {
+  for (let pageIndex = 0; pageIndex < PROMPT_RAIL_PROMPT_COUNT; pageIndex += 1) {
+    const firstBefore = await page.locator('[data-turn-id]').first().getAttribute('data-turn-id');
+    if (firstBefore === 'turn-prompt-rail-1') return;
+    await page.evaluate(() => {
+      const root = document.querySelector<HTMLElement>('[data-chat-scroll-container="true"]');
+      if (!root) throw new Error('the chat scroll container is missing');
+      root.scrollTop = 0;
+      root.dispatchEvent(new WheelEvent('wheel', { deltaY: -120, bubbles: true }));
+      root.dispatchEvent(new Event('scroll'));
+    });
+    await expect.poll(async () =>
+      page.locator('[data-turn-id]').first().getAttribute('data-turn-id'), {
+      message: `history loads before ${firstBefore}`,
+    }).not.toBe(firstBefore);
+    await waitForPaintedFrames(page);
+    await expectPromptRailMatchesReadingPosition(page);
+  }
+  throw new Error('the first prompt did not enter the active transcript range');
+}
+
 test('every tick paints a bar with a real box', async ({ promptRailWindow: page }) => {
   // Measured over ALL ticks, not a sample: a helper that skips what it cannot
   // evaluate creates its blind spot exactly where a regression lives.
@@ -270,6 +366,59 @@ test('the first click of a session lands on its prompt and holds', async ({
   expect(settled?.tickIsCurrent).toBe(true);
 });
 
+test('manual transcript scrolling keeps exactly the visible prompt current', async ({
+  promptRailWindow: page,
+}) => {
+  await page.setViewportSize({ width: 1_000, height: 700 });
+  await scrollTranscriptTo(page, 'bottom');
+  await expectPromptRailMatchesReadingPosition(page);
+  await expect(page.locator('.maka-prompt-rail-tick[aria-current="true"]')).toHaveCount(1);
+  await expect(page.locator('.maka-prompt-rail-tick').last()).toHaveAttribute(
+    'aria-current',
+    'true',
+  );
+
+  await page.evaluate(() => {
+    const rail = document.querySelector('.maka-prompt-rail');
+    if (!rail) throw new Error('the prompt rail is missing');
+    const counts: number[] = [];
+    const record = () => counts.push(
+      rail.querySelectorAll('.maka-prompt-rail-tick[aria-current="true"]').length,
+    );
+    const observer = new MutationObserver(record);
+    observer.observe(rail, {
+      attributes: true,
+      subtree: true,
+      attributeFilter: ['aria-current'],
+    });
+    record();
+    Object.assign(window, {
+      __makaPromptRailCurrentCounts: counts,
+      __makaPromptRailCurrentObserver: observer,
+    });
+  });
+
+  await scrollTranscriptThroughHistory(page);
+  await scrollTranscriptTo(page, 'top');
+  await expectPromptRailMatchesReadingPosition(page);
+  await expect(page.locator('.maka-prompt-rail-tick[aria-current="true"]')).toHaveCount(1);
+  await expect(page.locator('.maka-prompt-rail-tick').first()).toHaveAttribute(
+    'aria-current',
+    'true',
+  );
+
+  const currentCounts = await page.evaluate(() => {
+    const state = window as Window & {
+      __makaPromptRailCurrentCounts?: number[];
+      __makaPromptRailCurrentObserver?: MutationObserver;
+    };
+    state.__makaPromptRailCurrentObserver?.disconnect();
+    return state.__makaPromptRailCurrentCounts ?? [];
+  });
+  expect(currentCounts.length).toBeGreaterThan(1);
+  expect(currentCounts.every((count) => count === 1), currentCounts.join(',')).toBe(true);
+});
+
 test('active transcript Turns keep stable DOM identities while scrolling', async ({
   promptRailWindow: page,
 }) => {

packages/ui/src/__tests__/prompt-anchor-rail.test.ts

@@ -27,6 +27,8 @@ import {
   mergePromptAnchorRailTurns,
   observeActivePromptRailVisibility,
   PromptAnchorRail,
+  selectPromptRailActiveTurn,
+  selectPromptRailTickForMountedTurn,
   type PromptRailFrameScheduler,
 } from '../prompt-anchor-rail.js';
 
@@ -226,6 +228,120 @@ test('a jump gives the transcript back the moment the reader touches it', () =>
   harness.restore();
 });
 
+const turnIndexById = new Map([
+  ['turn-1', 0],
+  ['turn-2', 1],
+  ['turn-3', 2],
+  ['turn-4', 3],
+]);
+
+test('the transcript tail selects the latest mounted Turn', () => {
+  assert.equal(selectPromptRailActiveTurn({
+    atEnd: true,
+    mountedTurnIds: ['turn-3', 'turn-1', 'turn-4'],
+    readingBandTurnIds: ['turn-1'],
+    scrollportTurnIds: ['turn-1', 'turn-3'],
+    turnIndexById,
+  }), 'turn-4');
+});
+
+test('the reading band selects its earliest Turn by transcript order', () => {
+  assert.equal(selectPromptRailActiveTurn({
+    atEnd: false,
+    mountedTurnIds: ['turn-1', 'turn-2', 'turn-3', 'turn-4'],
+    readingBandTurnIds: ['turn-4', 'turn-2', 'turn-3'],
+    scrollportTurnIds: ['turn-1', 'turn-2', 'turn-3', 'turn-4'],
+    turnIndexById,
+  }), 'turn-2');
+});
+
+test('an empty reading band falls back to the earliest Turn in the scrollport', () => {
+  assert.equal(selectPromptRailActiveTurn({
+    atEnd: false,
+    mountedTurnIds: ['turn-1', 'turn-2', 'turn-3', 'turn-4'],
+    readingBandTurnIds: [],
+    scrollportTurnIds: ['turn-4', 'turn-3'],
+    turnIndexById,
+  }), 'turn-3');
+});
+
+test('no eligible Turn leaves the selection unresolved', () => {
+  assert.equal(selectPromptRailActiveTurn({
+    atEnd: false,
+    mountedTurnIds: ['unknown-turn'],
+    readingBandTurnIds: [],
+    scrollportTurnIds: [],
+    turnIndexById,
+  }), null);
+});
+
+test('an unsampled mounted Turn maps through the two nearest durable landmarks', () => {
+  const railTurns = Array.from({ length: 64 }, (_, railIndex) => {
+    const turnIndex = Math.round(railIndex * 119 / 63);
+    return { turnId: `turn-${turnIndex + 1}`, label: '', sequence: turnIndex * 2 };
+  });
+  assert.equal(selectPromptRailTickForMountedTurn({
+    activeTurnId: 'turn-66',
+    mountedTurnIds: ['turn-66', 'turn-67', 'turn-68', 'turn-69'],
+    railTurns,
+    previousRailTurnId: 'turn-67',
+  }), 'turn-65');
+});
+
+test('uneven sequence gaps choose a nearby real landmark instead of a linear tick position', () => {
+  const railTurns = [
+    { turnId: 'turn-a', label: '', sequence: 0 },
+    { turnId: 'turn-b', label: '', sequence: 10 },
+    { turnId: 'turn-c', label: '', sequence: 1_000 },
+    { turnId: 'turn-d', label: '', sequence: 1_010 },
+  ];
+  assert.equal(selectPromptRailTickForMountedTurn({
+    activeTurnId: 'active',
+    mountedTurnIds: ['turn-b', 'active', 'turn-c'],
+    railTurns,
+    previousRailTurnId: 'turn-b',
+  }), 'turn-c');
+});
+
+test('one-sided sequence extrapolation cannot skip past the adjacent tick', () => {
+  const railTurns = [
+    { turnId: 'turn-a', label: '', sequence: 0 },
+    { turnId: 'turn-b', label: '', sequence: 10 },
+    { turnId: 'turn-c', label: '', sequence: 1_000 },
+    { turnId: 'turn-d', label: '', sequence: 1_010 },
+  ];
+  assert.equal(selectPromptRailTickForMountedTurn({
+    activeTurnId: 'active',
+    mountedTurnIds: ['active', 'turn-b', 'turn-c'],
+    railTurns,
+    previousRailTurnId: 'turn-d',
+  }), 'turn-a');
+});
+
+test('a window without a sampled wrapper preserves its previous current tick', () => {
+  assert.equal(selectPromptRailTickForMountedTurn({
+    activeTurnId: 'active',
+    mountedTurnIds: ['active', 'neighbor'],
+    railTurns: [
+      { turnId: 'turn-a', label: '', sequence: 0 },
+      { turnId: 'turn-b', label: '', sequence: 10 },
+    ],
+    previousRailTurnId: 'turn-a',
+  }), 'turn-a');
+});
+
+test('a window without landmarks replaces a stale current with a current rail tick', () => {
+  assert.equal(selectPromptRailTickForMountedTurn({
+    activeTurnId: 'active',
+    mountedTurnIds: ['active'],
+    railTurns: [
+      { turnId: 'turn-a', label: '', sequence: 0 },
+      { turnId: 'turn-b', label: '', sequence: 10 },
+    ],
+    previousRailTurnId: 'stale-turn',
+  }), 'turn-a');
+});
+
 test('keeps the active tick visible when the rail viewport resizes', () => {
   let railBox = box(0, 600);
   let tickBox = box(570, 590);