@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/promptTimeline/promptTimelineGutterRail.js

@@ -0,0 +1,440 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { $, append, addDisposableListener, EventType, clearNode, getWindow, getActiveElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { StandardKeyboardEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/keyboardEvent';
+import { Gesture, EventType as EventType$1 } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/touch';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { Disposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { MIN_HOST_WIDTH } from './promptTimelineLayout.js';
+import * as promptTimeline from './media/promptTimeline.css';
+
+registerCss(promptTimeline);
+const MAX_REST_DOTS = 50;
+const MIN_REST_DOTS = 2;
+const DOT_SIZE = 4;
+const DOT_GAP = 4;
+const HANDLE_PADDING_Y = 8;
+const MORE_MARKER_HEIGHT = 8;
+const GUTTER_INSET = 12;
+function restDotCount(promptCount, railHeight) {
+    const capped = Math.min(promptCount, MAX_REST_DOTS);
+    if (promptCount <= MIN_REST_DOTS || railHeight <= 0) {
+        return capped;
+    }
+    const available = railHeight - 2 * (GUTTER_INSET + HANDLE_PADDING_Y);
+    const step = DOT_SIZE + DOT_GAP;
+    if (capped === promptCount && Math.floor((available + DOT_GAP) / step) >= promptCount) {
+        return capped;
+    }
+    return Math.max(
+        MIN_REST_DOTS,
+        Math.min(capped, Math.floor((available - MORE_MARKER_HEIGHT) / step))
+    );
+}
+let gutterIdSeq = 0;
+class PromptTimelineGutterRail extends Disposable {
+    get domNode() {
+        return this._domNode;
+    }
+    constructor() {
+        super();
+        this._rowDisposables = this._register(( new DisposableStore()));
+        this._dotDisposables = this._register(( new DisposableStore()));
+        this._rows = [];
+        this._dots = [];
+        this._dotTicks = [];
+        this._hostWidth = Number.POSITIVE_INFINITY;
+        this._railHeight = 0;
+        this._resizeObserverReady = false;
+        this._tickCount = 0;
+        this._open = false;
+        this._hovering = false;
+        this._previewIndex = -1;
+        this._previewBand = -1;
+        this._activeIndex = -1;
+        this._focusRow = 0;
+        this._focusColumn = "jump";
+        this._onDidSelect = this._register(( new Emitter()));
+        this.onDidSelect = this._onDidSelect.event;
+        this._onDidReview = this._register(( new Emitter()));
+        this.onDidReview = this._onDidReview.event;
+        this._onDidReviewFile = this._register(( new Emitter()));
+        this.onDidReviewFile = this._onDidReviewFile.event;
+        this._domNode = $("nav.prompt-timeline-rail.prompt-timeline-rail-gutter");
+        this._domNode.setAttribute("aria-label", ( localize(8884, "Prompt timeline")));
+        this._domNode.setAttribute("role", "toolbar");
+        this._domNode.setAttribute("aria-orientation", "vertical");
+        const panelId = `prompt-timeline-gutter-panel-${gutterIdSeq++}`;
+        this._rest = append(this._domNode, $("button.prompt-timeline-gutter-rest"));
+        this._rest.setAttribute("aria-haspopup", "true");
+        this._rest.setAttribute("aria-expanded", "false");
+        this._rest.setAttribute("aria-controls", panelId);
+        this._rest.setAttribute("aria-label", ( localize(8885, "Show prompts")));
+        this._rest.tabIndex = 0;
+        this._list = append(this._domNode, $(".prompt-timeline-gutter-panel"));
+        this._list.id = panelId;
+        this._register(addDisposableListener(this._domNode, EventType.MOUSE_OVER, () => {
+            this._hovering = true;
+            this._updateRevealed();
+        }));
+        this._register(addDisposableListener(this._domNode, EventType.MOUSE_OUT, e => {
+            if (!this._domNode.contains(e.relatedTarget)) {
+                this._hovering = false;
+                this._setPreview(-1);
+                this._updateRevealed();
+            }
+        }));
+        this._register(addDisposableListener(this._list, EventType.MOUSE_OVER, e => {
+            const target = e.target;
+            const rowIndex = target === null ? -1 : this._rows.findIndex(row => row.container.contains(target));
+            this._setPreview(rowIndex, "row");
+        }));
+        this._register(Gesture.addTarget(this._rest));
+        this._register(addDisposableListener(this._rest, EventType.CLICK, e => {
+            e.preventDefault();
+            this._toggleOpen();
+        }));
+        this._register(
+            addDisposableListener(this._rest, EventType$1.Tap, () => this._toggleOpen())
+        );
+        this._register(addDisposableListener(this._rest, EventType.KEY_DOWN, e => {
+            const event = ( new StandardKeyboardEvent(e));
+            if (event.keyCode === KeyCode.Enter || event.keyCode === KeyCode.Space) {
+                event.preventDefault();
+                event.stopPropagation();
+                this._toggleOpen();
+            }
+        }));
+        this._register(
+            addDisposableListener(this._list, EventType.KEY_DOWN, e => this._onListKeyDown(e))
+        );
+        this._register(addDisposableListener(this._domNode, EventType.FOCUS_OUT, e => {
+            if (!this._domNode.contains(e.relatedTarget)) {
+                this._open = false;
+                this._updateRevealed();
+            }
+        }));
+    }
+    _updateRevealed() {
+        const revealed = this._open || this._hovering;
+        this._domNode.classList.toggle("revealed", revealed);
+        this._rest.setAttribute("aria-expanded", String(revealed));
+    }
+    _toggleOpen() {
+        if (this._open) {
+            this._close();
+        } else {
+            this._open = true;
+            this._updateRevealed();
+            this._focusActiveRow();
+        }
+    }
+    _close(restoreFocus = true) {
+        this._open = false;
+        this._updateRevealed();
+        if (restoreFocus) {
+            this._rest.focus();
+        }
+    }
+    _focusActiveRow() {
+        this._focusCell(this._focusRow, this._focusColumn);
+    }
+    setFilesProvider(_provider) {}
+    _renderDots(count) {
+        this._dotDisposables.clear();
+        clearNode(this._rest);
+        this._dots.length = 0;
+        this._dotTicks.length = 0;
+        const dots = restDotCount(count, this._railHeight);
+        for (let i = 0; i < dots; i++) {
+            const dot = append(this._rest, $(".prompt-timeline-gutter-dot"));
+            const tickIndex = dots === count ? i : Math.round(i * (count - 1) / (dots - 1));
+            this._dots.push(dot);
+            this._dotTicks.push(tickIndex);
+            this._dotDisposables.add(
+                addDisposableListener(dot, EventType.MOUSE_OVER, () => this._setPreview(tickIndex))
+            );
+        }
+        if (count > dots) {
+            append(this._rest, $(".prompt-timeline-gutter-dot-more"));
+        }
+        this._updateDotHighlights();
+    }
+    _ensureResizeObserver() {
+        if (this._resizeObserverReady) {
+            return;
+        }
+        const ResizeObserverCtor = getWindow(this._domNode).ResizeObserver;
+        if (!ResizeObserverCtor) {
+            return;
+        }
+        this._resizeObserverReady = true;
+        const observer = ( new ResizeObserverCtor(() => {
+            const height = this._domNode.clientHeight;
+            if (height <= 0 || height === this._railHeight) {
+                return;
+            }
+            this._railHeight = height;
+            if (restDotCount(this._tickCount, height) !== this._dots.length) {
+                this._renderDots(this._tickCount);
+            }
+        }));
+        observer.observe(this._domNode);
+        this._register(toDisposable(() => observer.disconnect()));
+    }
+    _setPreview(index, source = "dot") {
+        const band = source === "dot" ? index : -1;
+        if (this._previewIndex === index && this._previewBand === band) {
+            return;
+        }
+        this._previewIndex = index;
+        this._previewBand = band;
+        for (let i = 0; i < this._rows.length; i++) {
+            this._rows[i].container.classList.toggle("preview", i === band);
+        }
+        this._updateDotHighlights();
+        if (index >= 0) {
+            this._revealRow(index);
+        }
+    }
+    _updateDotHighlights() {
+        const activeDot = this._findNearestDotIndex(this._activeIndex);
+        const previewDot = this._findNearestDotIndex(this._previewIndex);
+        for (let i = 0; i < this._dots.length; i++) {
+            this._dots[i].classList.toggle("active", i === activeDot);
+            this._dots[i].classList.toggle("preview", i === previewDot);
+        }
+    }
+    _findNearestDotIndex(tickIndex) {
+        if (tickIndex < 0) {
+            return -1;
+        }
+        let nearestDot = -1;
+        let bestDelta = Number.POSITIVE_INFINITY;
+        for (let i = 0; i < this._dotTicks.length; i++) {
+            const delta = Math.abs(this._dotTicks[i] - tickIndex);
+            if (delta < bestDelta) {
+                bestDelta = delta;
+                nearestDot = i;
+            }
+        }
+        return nearestDot;
+    }
+    _revealRow(index) {
+        const container = this._rows[index]?.container;
+        if (!container) {
+            return;
+        }
+        const top = container.offsetTop;
+        const bottom = top + container.offsetHeight;
+        const viewTop = this._list.scrollTop;
+        const viewBottom = viewTop + this._list.clientHeight;
+        if (top < viewTop) {
+            this._list.scrollTop = top;
+        } else if (bottom > viewBottom) {
+            this._list.scrollTop = bottom - this._list.clientHeight;
+        }
+    }
+    setTicks(ticks) {
+        this._tickCount = ticks.length;
+        this._ensureResizeObserver();
+        if (this._railHeight <= 0) {
+            this._railHeight = this._domNode.clientHeight;
+        }
+        const sameStructure = ticks.length === this._rows.length && ticks.every((t, i) => this._rows[i]?.tick.requestId === t.requestId);
+        if (sameStructure) {
+            const activeElement = getActiveElement(this._domNode.ownerDocument);
+            const focusedCell = this._isLiveCell(activeElement) ? activeElement : undefined;
+            for (let i = 0; i < ticks.length; i++) {
+                this._renderRow(this._rows[i], ticks[i]);
+            }
+            this._updateTabStops(this._focusRow, this._focusColumn);
+            if (focusedCell && !this._isLiveCell(focusedCell)) {
+                this._cell(this._focusRow, this._focusColumn)?.focus();
+            }
+            this._updateActiveClasses();
+            return;
+        }
+        this._rowDisposables.clear();
+        this._rows.length = 0;
+        this._previewIndex = -1;
+        this._previewBand = -1;
+        clearNode(this._list);
+        this._renderDots(ticks.length);
+        for (const tick of ticks) {
+            const container = append(this._list, $(".prompt-timeline-gutter-row"));
+            const jump = append(container, $("button.prompt-timeline-gutter-row-jump"));
+            jump.tabIndex = -1;
+            const label = append(jump, $("span.prompt-timeline-gutter-row-label"));
+            const diff = append(container, $("button.prompt-timeline-gutter-row-diff"));
+            diff.tabIndex = -1;
+            const stat = append(diff, $("span.prompt-timeline-gutter-row-stat"));
+            const entry = {
+                tick,
+                container,
+                jump,
+                diff,
+                label,
+                stat
+            };
+            this._renderRow(entry, tick);
+            const requestId = tick.requestId;
+            this._rowDisposables.add(addDisposableListener(jump, EventType.CLICK, () => {
+                this._onDidSelect.fire(requestId);
+                this._close();
+            }));
+            this._rowDisposables.add(addDisposableListener(diff, EventType.CLICK, () => {
+                this._onDidReview.fire(entry.tick);
+                this._close( false);
+            }));
+            for (const [button, column] of [[jump, "jump"], [diff, "diff"]]) {
+                this._rowDisposables.add(addDisposableListener(button, EventType.FOCUS, () => {
+                    this._open = true;
+                    this._updateRevealed();
+                    this._updateTabStops(this._rows.indexOf(entry), column);
+                }));
+            }
+            this._rows.push(entry);
+        }
+        const activeIndex = this._rows.findIndex(r => r.tick.requestId === this._activeRequestId);
+        this._updateTabStops(activeIndex >= 0 ? activeIndex : 0, "jump");
+        this._updateActiveClasses();
+    }
+    _renderRow(entry, tick) {
+        entry.tick = tick;
+        entry.jump.setAttribute("aria-label", tick.ariaLabel);
+        entry.label.textContent = tick.text;
+        entry.label.title = tick.text;
+        const stat = tick.stat && tick.stat.added + tick.stat.removed > 0 ? tick.stat : undefined;
+        this._renderStat(entry.stat, stat);
+        entry.container.classList.toggle("reviewable", !!stat);
+        if (stat) {
+            entry.diff.setAttribute("aria-label", ( localize(
+                8886,
+                "Review Changes for Prompt: {0}, {1}",
+                tick.text,
+                stat.fileCount === 1 ? ( localize(8887, "1 file changed")) : ( localize(8888, "{0} files changed", stat.fileCount))
+            )));
+        }
+    }
+    _renderStat(container, stat) {
+        clearNode(container);
+        if (!stat) {
+            return;
+        }
+        append(container, $("span.added")).textContent = `+${stat.added}`;
+        append(container, $("span.removed")).textContent = `\u2212${stat.removed}`;
+    }
+    _cell(rowIndex, column) {
+        const entry = this._rows[rowIndex];
+        if (!entry) {
+            return undefined;
+        }
+        if (column === "jump") {
+            return entry.jump;
+        }
+        return entry.container.classList.contains("reviewable") ? entry.diff : undefined;
+    }
+    _isLiveCell(element) {
+        return ( this._rows.some(
+            row => row.jump === element || (row.diff === element && row.container.classList.contains("reviewable"))
+        ));
+    }
+    _updateTabStops(focusIndex, column = this._focusColumn) {
+        this._focusRow = Math.max(0, Math.min(this._rows.length - 1, focusIndex));
+        this._focusColumn = this._cell(this._focusRow, column) ? column : "jump";
+        const focused = this._cell(this._focusRow, this._focusColumn);
+        for (const entry of this._rows) {
+            entry.jump.tabIndex = entry.jump === focused ? 0 : -1;
+            entry.diff.tabIndex = entry.diff === focused ? 0 : -1;
+        }
+    }
+    _focusCell(rowIndex, column) {
+        this._updateTabStops(rowIndex, column);
+        this._cell(this._focusRow, this._focusColumn)?.focus();
+    }
+    _onListKeyDown(e) {
+        if (this._rows.length === 0) {
+            return;
+        }
+        const event = ( new StandardKeyboardEvent(e));
+        if (event.keyCode === KeyCode.Escape) {
+            event.preventDefault();
+            event.stopPropagation();
+            this._close();
+            return;
+        }
+        const activeElement = getActiveElement(this._domNode.ownerDocument);
+        const currentIndex = this._rows.findIndex(r => r.jump === activeElement || r.diff === activeElement);
+        const currentColumn = this._rows[currentIndex]?.diff === activeElement ? "diff" : "jump";
+        let nextIndex = currentIndex;
+        let nextColumn = currentColumn;
+        switch (event.keyCode) {
+        case KeyCode.DownArrow:
+            nextIndex = Math.min(this._rows.length - 1, currentIndex + 1);
+            break;
+        case KeyCode.UpArrow:
+            nextIndex = Math.max(0, currentIndex - 1);
+            break;
+        case KeyCode.Home:
+            nextIndex = 0;
+            break;
+        case KeyCode.End:
+            nextIndex = this._rows.length - 1;
+            break;
+        case KeyCode.RightArrow:
+            nextColumn = "diff";
+            break;
+        case KeyCode.LeftArrow:
+            nextColumn = "jump";
+            break;
+        default:
+            return;
+        }
+        event.preventDefault();
+        event.stopPropagation();
+        this._focusCell(nextIndex, nextColumn);
+    }
+    setActive(requestId) {
+        this._activeRequestId = requestId;
+        this._updateActiveClasses();
+    }
+    _updateActiveClasses() {
+        let activeIndex = -1;
+        for (let i = 0; i < this._rows.length; i++) {
+            const row = this._rows[i];
+            const active = this._activeRequestId !== undefined && (row.tick.requestId === this._activeRequestId || row.tick.allRequestIds.includes(this._activeRequestId));
+            if (active) {
+                activeIndex = i;
+            }
+            row.container.classList.toggle("active", active);
+            if (active) {
+                row.jump.setAttribute("aria-current", "location");
+            } else {
+                row.jump.removeAttribute("aria-current");
+            }
+        }
+        this._activeIndex = activeIndex;
+        this._updateDotHighlights();
+    }
+    focusTick(requestId) {
+        const index = this._rows.findIndex(
+            r => r.tick.requestId === requestId || r.tick.allRequestIds.includes(requestId)
+        );
+        if (index >= 0) {
+            this._focusCell(index, "jump");
+        }
+    }
+    setHostWidth(width) {
+        if (width > 0 && width !== this._hostWidth) {
+            this._hostWidth = width;
+            this._domNode.classList.toggle("overflowing", width < MIN_HOST_WIDTH);
+        }
+    }
+    notifyHardWheel() {}
+    setScrollLayout(_layout) {}
+}
+
+export { PromptTimelineGutterRail, restDotCount };

package/vscode/src/vs/workbench/contrib/chat/browser/promptTimeline/promptTimelineLayout.d.ts

@@ -0,0 +1,16 @@
+/** Below this transcript width a rail hides so it does not crowd the content (the native scrollbar is kept). */
+export declare const MIN_HOST_WIDTH = 320;
+/** A rail mark with a mutable centre position (px), used by {@link spaceMarkCenters}. */
+export interface IPositionedMark {
+    center: number;
+}
+/**
+ * Nudges ascending mark centres so no two are closer than `minGap`, keeping them within the rail
+ * `[minGap/2, height - minGap/2]` and as near their desired (proportional) position as room
+ * allows. Prompts can sit arbitrarily close in content space (a short turn, or once the adaptive
+ * height estimates settle), which would otherwise let the marks' clickable hit targets overlap.
+ *
+ * When the marks cannot all fit at full spacing they are distributed evenly (the best achievable).
+ * Mutates `marks[i].center` in place; `marks` must already be sorted by ascending `center`.
+ */
+export declare function spaceMarkCenters(marks: readonly IPositionedMark[], height: number, minGap: number): void;

package/vscode/src/vs/workbench/contrib/chat/browser/promptTimeline/promptTimelineLayout.js

@@ -0,0 +1,5 @@
+
+
+const MIN_HOST_WIDTH = 320;
+
+export { MIN_HOST_WIDTH };

package/vscode/src/vs/workbench/contrib/chat/browser/promptTimeline/promptTimelineModel.d.ts

@@ -0,0 +1,194 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { ChatWidget } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/widget/chatWidget";
+import { IChatResponseFileChangesService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatResponseFileChangesService.service";
+import { IChatEditingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService.service";
+/** Aggregated diff stats for the edits a prompt (or bucket) produced. */
+export interface PromptDiffStat {
+    readonly added: number;
+    readonly removed: number;
+    readonly fileCount: number;
+}
+/** A single file changed by a prompt, used by the hover card / diff drill-down. */
+export interface PromptFileDiff {
+    readonly name: string;
+    readonly originalURI: URI;
+    /** File identity / go-to-file target (may be the live working file). */
+    readonly modifiedURI: URI;
+    /** RHS content the diff should render; the frozen after-turn snapshot when available. */
+    readonly diffModifiedURI: URI;
+    readonly added: number;
+    readonly removed: number;
+}
+/** Content-space layout used by the overview-ruler rail to place the prompt marks. */
+export interface IPromptScrollLayout {
+    /** Each prompt's top offset in the rail's estimated content space. */
+    readonly marks: readonly {
+        readonly requestId: string;
+        readonly top: number;
+    }[];
+    /** Total content height in the estimated space, matching `marks`. */
+    readonly total: number;
+    /** Current scroll offset (px, the transcript's real scroll space) — drives the rail's own scrollbar thumb. */
+    readonly scrollTop: number;
+    /** Full scrollable content height (px, the transcript's real scroll space). */
+    readonly scrollHeight: number;
+    /** Visible viewport height (px) of the transcript list — the scrollbar's `visibleSize`. */
+    readonly viewportHeight: number;
+}
+/** A single tick shown on the prompt timeline rail. */
+export interface PromptTick {
+    /** Jump target: the request id of the first prompt in the bucket. */
+    readonly requestId: string;
+    /** Request ids of every prompt this tick represents (for active tracking). */
+    readonly allRequestIds: readonly string[];
+    /** Preview text (first prompt in the bucket). */
+    readonly text: string;
+    /** Creation time (ms since epoch) of the first prompt in the bucket. */
+    readonly timestamp: number;
+    /** How many prompts this tick represents. */
+    readonly count: number;
+    /** Accessible label announced for the tick. */
+    readonly ariaLabel: string;
+    /** Diff summary of the edits this tick produced, if any. */
+    readonly stat?: PromptDiffStat;
+}
+/** The prompt currently pinned by the sticky header, with its 1-based position among all prompts. */
+export interface IActivePrompt {
+    readonly text: string;
+    readonly index: number;
+    readonly total: number;
+}
+/**
+ * Derives the prompt timeline (bucketed ticks + the active tick) from a chat
+ * widget's view model, and reveals prompts on request.
+ */
+export declare class PromptTimelineModel extends Disposable {
+    private readonly widget;
+    private readonly chatEditingService;
+    private readonly chatResponseFileChangesService;
+    private readonly editorService;
+    private readonly instantiationService;
+    private readonly fileService;
+    /** All user prompts in the chat, updated as the transcript changes. */
+    private readonly _prompts;
+    /** The chat session resource, tracked reactively so the editing session can be resolved. */
+    private readonly _sessionResource;
+    /** The chat editing session for this chat, if one exists (local or agent-host). */
+    private readonly _editingSession;
+    /** Recency-bucketed ticks, capped to a fixed maximum so each keeps a >=24px slot. */
+    private readonly _baseTicks;
+    /** Ticks decorated with per-prompt diff stats (server per-turn changeset, else editing session). */
+    private readonly _ticks;
+    get ticks(): IObservable<readonly PromptTick[]>;
+    /**
+     * One tick per user prompt — unbucketed and uncapped, decorated with per-prompt diff stats. The
+     * gutter rail lists every prompt as its own entry (no recency bucketing/sampling), so it needs the
+     * raw prompt list rather than the capped {@link ticks} the overview ruler uses.
+     */
+    private readonly _promptTicks;
+    get promptTicks(): IObservable<readonly PromptTick[]>;
+    private readonly _activeRequestId;
+    get activeRequestId(): IObservable<string | undefined>;
+    /** The exact request currently scrolled to the top, unbucketed — drives the sticky header's label/position and the gutter rail's active row. */
+    private readonly _activePromptId;
+    get activePromptId(): IObservable<string | undefined>;
+    /** True once the active prompt's own row has scrolled above the viewport top (drives the sticky header). */
+    private readonly _scrollPinned;
+    get activePinned(): IObservable<boolean>;
+    /** The active prompt with its 1-based position among all (unbucketed) prompts, for the sticky header. */
+    private readonly _activePrompt;
+    get activePrompt(): IObservable<IActivePrompt | undefined>;
+    /** Fires when the transcript scroll offset or content height changes (drives the ruler rail). */
+    private readonly _scrollLayoutSignal;
+    get onDidChangeScrollLayout(): IObservable<void>;
+    private readonly _viewModelListener;
+    /** Per-item content-signal cache (id -> {version, signal}) for height estimation; version invalidates on content growth. */
+    private readonly _signalCache;
+    /** Per-request preview cache (id -> {messageText, preview}); recognizing an Agent Merge turn parses its whole state block, and `_recompute` runs on every streamed token. */
+    private readonly _previewCache;
+    constructor(widget: ChatWidget, chatEditingService: IChatEditingService, chatResponseFileChangesService: IChatResponseFileChangesService, editorService: IEditorService, instantiationService: IInstantiationService, fileService: IFileService);
+    private _triggerScrollLayout;
+    /**
+     * The prompts' positions for the overview-ruler rail, in an *estimated*
+     * content space that stays stable while the transcript virtualizes. The rail
+     * draws its own scrollbar thumb from `scrollTop`/`scrollHeight` (the transcript's
+     * native scrollbar is hidden while the rail is active) so the whole lane is one
+     * surface: a plain scrollbar that blooms into the prompt fan on engagement.
+     *
+     * The chat list's own height model (`getElementTop`/`scrollHeight`) guesses
+     * every un-rendered row at one flat default height (200px). Real turns are
+     * nothing like flat — prompts are short, responses tall and variable — so as
+     * rows render and get measured the list's tops snap around, dragging the marks
+     * with them (the "scroll jitter"). For the marks we instead build our own
+     * heights: measured rows use their real `currentRenderedHeight`; un-measured
+     * rows are estimated from a content signal calibrated to measured rows (see
+     * `_computeAdaptiveLayout`), so marks land near their final spot immediately and
+     * barely drift. Once every row is measured this estimate equals the list's real
+     * layout.
+     */
+    getScrollLayout(): IPromptScrollLayout | undefined;
+    /**
+     * Builds a per-item content-height model for the marks. Measured rows
+     * contribute their real rendered height; un-measured rows are estimated from a
+     * cheap content signal (~ rendered line count) scaled by a pixels-per-unit
+     * factor *learned from the measured rows of the same kind*, so the estimate
+     * calibrates to the real line height/width instead of relying on magic
+     * constants. Falls back to a seed factor until a row of that kind is measured.
+     */
+    private _computeAdaptiveLayout;
+    /**
+     * A cheap, unit-less size proxy for a row (~ rendered line count), used to
+     * estimate un-measured rows. Cached per item and only recomputed when the
+     * content grows (responses stream), so scanning every row on each scroll stays
+     * cheap even for long sessions.
+     */
+    private _itemSignal;
+    /**
+     * Preview of a prompt, which for a request rendered as something other than
+     * its own text (an Agent Merge turn) previews that stand-in label instead.
+     */
+    private _requestPreview;
+    private _bindViewModel;
+    private _recompute;
+    /** Recomputes which tick maps to the prompt currently scrolled into view. */
+    private _updateActive;
+    /** Reveals the request with the given id at the top of the transcript. */
+    reveal(requestId: string): void;
+    /**
+     * Reveals the prompt the sticky header currently names (the prompt scrolled to the top). Used when the
+     * header's label is activated so it jumps straight to that prompt, aligned to the top of the transcript.
+     */
+    revealActivePrompt(): void;
+    /** The changed files for a tick's prompts, aggregated per file (for the hover card / drill-down). */
+    getRequestFiles(tick: PromptTick): readonly PromptFileDiff[];
+    /**
+     * Opens the per-prompt changes as a multi-file diff. When a specific file is
+     * given (a file row in the card), the same multi-diff is opened but revealed
+     * at that file, so per-file and whole-prompt review share one experience.
+     */
+    reviewChanges(tick: PromptTick, file?: URI): Promise<void>;
+    /**
+     * Resolves which sides of a file diff can actually be read. Prefers the frozen
+     * before/after snapshots so only this turn's changes show, but the agent-host
+     * checkpoint blobs backing them can be missing (an added file's original, or a
+     * pruned/restored session where whole checkpoints are gone). The modified side
+     * then falls back to the live working file so review still opens with the best
+     * available fidelity; an unreadable side is dropped so the file still renders
+     * as a pure add/delete instead of crashing the diff editor.
+     */
+    private _readableSides;
+    private _canRead;
+    /**
+     * Per-request file diffs, preferring the session type's authoritative
+     * provider (agent-host sessions expose a server-computed per-turn changeset
+     * that survives reload), and falling back to the chat editing session.
+     */
+    private _diffsForRequest;
+    /** Sums the diff stats across the given requests, or undefined when nothing changed. */
+    private _statForRequests;
+}