fix(terminal): defer keyword scroll refresh while Enter is pending

components/terminal/keywordHighlight.test.ts

@@ -2083,6 +2083,72 @@ test("pressing Enter does not repaint after keyword markers move", async () => {
   }
 });
 
+test("idle Enter scroll before writeParsed does not rescan visible keywords", () => {
+  const raf = installAnimationFrameQueue();
+  try {
+    const {
+      term,
+      decorationStates,
+      handlers,
+      getTranslateCount,
+      resetTranslateCount,
+      refreshCalls,
+      resetRefreshCalls,
+    } = createFakeTerminal("hello DEPLOY world", { lineCount: 40 });
+    term.buffer.active.viewportY = 20;
+    term.buffer.active.baseY = 20;
+    term.buffer.active.cursorY = 2;
+    const highlighter = new KeywordHighlighter(term as never);
+    highlighter.setRules([{
+      id: "deploy",
+      label: "Deploy",
+      patterns: ["DEPLOY"],
+      color: "#F87171",
+      enabled: true,
+    }], true);
+    raf.flush();
+    const existingDecorations = [...decorationStates];
+    assert.ok(existingDecorations.length > 0);
+
+    // Ordinary write refreshes clear lastRenderRange. An idle prompt then has no
+    // scroll coverage hint, so Enter echo onScroll (before writeParsed, Ubuntu RTT)
+    // would otherwise take the immediate user-scroll path and rescan the viewport.
+    const internals = highlighter as unknown as {
+      lastWriteAt: number;
+      lastRenderRange: { start: number; end: number } | null;
+    };
+    internals.lastWriteAt = performance.now() - 10_000;
+    internals.lastRenderRange = null;
+    resetTranslateCount();
+    resetRefreshCalls();
+
+    handlers.data?.("\r");
+    term.buffer.active.viewportY += 1;
+    term.buffer.active.baseY += 1;
+    term.buffer.active.length += 1;
+    handlers.scroll?.();
+
+    assert.equal(
+      getTranslateCount(),
+      0,
+      "Enter-pending scroll before writeParsed must not rescan visible keywords",
+    );
+    assert.deepEqual(
+      refreshCalls,
+      [],
+      "Enter-pending scroll before writeParsed must not force a keyword repaint",
+    );
+    assert.equal(
+      existingDecorations.filter(({ isDisposed }) => isDisposed).length,
+      0,
+      "Enter-pending scroll must keep existing keyword decorations mounted",
+    );
+    highlighter.dispose();
+  } finally {
+    raf.restore();
+  }
+});
+
 test("long-line pressure avoids scanning across a whole soft-wrapped logical line", () => {
   const raf = installAnimationFrameQueue();
   try {

components/terminal/keywordHighlight.ts

@@ -157,6 +157,13 @@ export class KeywordHighlighter implements IDisposable {
             clearTimeout(this.enterInputIdleTimer);
             this.enterInputIdleTimer = null;
           }
+          // Drop any pending user-scroll refresh so Enter echo cannot finish a
+          // scroll pass that rescans/repaints still-visible keyword decorations
+          // before onWriteParsed owns the write path (Ubuntu RTT).
+          if (this.pendingRefreshReason === "scroll") {
+            this.cancelQueuedRefreshSchedule();
+            this.pendingRefreshReason = "write";
+          }
         }
       }),
       // When new data is written, refresh on the next frame so highlights land
@@ -706,6 +713,20 @@ export class KeywordHighlighter implements IDisposable {
   }
 
   private triggerViewportChangeRefresh() {
+    // Enter echo often emits onScroll before onWriteParsed. After an idle gap
+    // lastWriteAt looks stale and lastRenderRange is usually null (cleared by
+    // the previous write refresh), so the user-scroll path would synchronously
+    // rescan the viewport and flash keywords still on screen. While Enter
+    // output is pending, skip scroll refresh but mark dirty so writeParsed /
+    // idle-clear can catch up (including user scroll during the window).
+    if (this.enterInputPending) {
+      if (this.pendingRefreshReason === "scroll") {
+        this.cancelQueuedRefreshSchedule();
+        this.pendingRefreshReason = "write";
+      }
+      this.markVisibleRangeDirty();
+      return;
+    }
     const now = performance.now();
     const buffer = this.term.buffer.active;
     const isBrowsingScrollback = buffer.viewportY < buffer.baseY;
@@ -1061,6 +1082,10 @@ export class KeywordHighlighter implements IDisposable {
     this.enterInputIdleTimer = setTimeout(() => {
       this.enterInputIdleTimer = null;
       this.enterInputPending = false;
+      // Catch up any viewport motion deferred while Enter protection blocked
+      // scroll refresh (e.g. user scrolled during the post-Enter window).
+      this.markVisibleRangeDirty();
+      this.triggerRefresh("debounced", "write");
     }, KeywordHighlighter.WRITE_PRUNE_IDLE_MS);
   }