[Init] Initial commit - NetMesh terminal manager

components/terminal/GhostTextAddon.test.ts

@@ -0,0 +1,918 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { GhostTextAddon } from "./autocomplete/GhostTextAddon.ts";
+
+type RenderListener = () => void;
+type ResizeListener = () => void;
+
+class FakeElement {
+  public readonly style: Record<string, string> = {};
+  public textContent = "";
+  public className = "";
+  public children: FakeElement[] = [];
+
+  appendChild(child: FakeElement): FakeElement {
+    this.children.push(child);
+    return child;
+  }
+
+  insertBefore(child: FakeElement, referenceNode: FakeElement | null): FakeElement {
+    if (!referenceNode) {
+      this.children.push(child);
+      return child;
+    }
+    const index = this.children.indexOf(referenceNode);
+    if (index < 0) {
+      this.children.push(child);
+      return child;
+    }
+    this.children.splice(index, 0, child);
+    return child;
+  }
+
+  remove(): void {
+    // No-op for tests.
+  }
+
+  querySelector(selector: string): FakeElement | null {
+    if (selector === ".xterm-screen") {
+      return this.children.find((child) => child.className === "xterm-screen") ?? null;
+    }
+    return null;
+  }
+}
+
+function installFakeDocument(): () => void {
+  const previousDocument = globalThis.document;
+  const fakeDocument = {
+    createElement() {
+      return new FakeElement();
+    },
+  } as unknown as Document;
+  Object.defineProperty(globalThis, "document", {
+    configurable: true,
+    value: fakeDocument,
+  });
+  return () => {
+    if (previousDocument === undefined) {
+      delete (globalThis as { document?: Document }).document;
+      return;
+    }
+    Object.defineProperty(globalThis, "document", {
+      configurable: true,
+      value: previousDocument,
+    });
+  };
+}
+
+function createFakeTerm() {
+  const renderListeners: RenderListener[] = [];
+  const resizeListeners: ResizeListener[] = [];
+  const element = new FakeElement();
+  const screen = new FakeElement();
+  screen.className = "xterm-screen";
+  element.appendChild(screen);
+
+  const term = {
+    element,
+    cols: 80,
+    rows: 24,
+    options: {
+      fontSize: 14,
+      fontFamily: "monospace",
+    },
+    buffer: {
+      active: {
+        cursorX: 2,
+        cursorY: 0,
+      },
+    },
+    _core: {
+      _renderService: {
+        dimensions: {
+          css: {
+            cell: {
+              width: 9,
+              height: 18,
+            },
+          },
+        },
+      },
+    },
+    onRender(listener: RenderListener) {
+      renderListeners.push(listener);
+      return {
+        dispose() {
+          const index = renderListeners.indexOf(listener);
+          if (index >= 0) renderListeners.splice(index, 1);
+        },
+      };
+    },
+    onResize(listener: ResizeListener) {
+      resizeListeners.push(listener);
+      return {
+        dispose() {
+          const index = resizeListeners.indexOf(listener);
+          if (index >= 0) resizeListeners.splice(index, 1);
+        },
+      };
+    },
+  };
+
+  return {
+    term,
+    ghostElement: () => screen.children[0]?.children[0] ?? null,
+    fireRender() {
+      for (const listener of [...renderListeners]) listener();
+    },
+  };
+}
+
+test("shifts ghost to predicted cursor column as matching input is typed", () => {
+  const restoreDocument = installFakeDocument();
+  const { term, ghostElement } = createFakeTerm();
+  const addon = new GhostTextAddon();
+
+  try {
+    addon.activate(term as never);
+    addon.show("docker", "do");
+
+    const ghost = ghostElement();
+    assert.ok(ghost);
+    assert.equal(ghost.style.display, "block");
+    assert.equal(ghost.textContent, "cker");
+    // show() anchored at cursorX=2, cell width=9 → left=18.
+    assert.equal(ghost.style.left, "18px");
+
+    addon.adjustToInput("doc");
+
+    // After one matching char, the ghost predicts the cursor has moved
+    // to column 3 and trims "c" from the tail so the next char starts
+    // where the echo will land. Not waiting for xterm's render keeps
+    // ghost + real input aligned across SSH echo latency.
+    assert.equal(ghost.style.display, "block");
+    assert.equal(ghost.textContent, "ker");
+    assert.equal(ghost.style.left, "27px");
+    assert.equal(addon.getGhostText(), "ker");
+  } finally {
+    restoreDocument();
+  }
+});
+
+test("walks the anchor column backwards on backspace so the ghost re-aligns", () => {
+  const restoreDocument = installFakeDocument();
+  const { term, ghostElement } = createFakeTerm();
+  const addon = new GhostTextAddon();
+
+  try {
+    addon.activate(term as never);
+    addon.show("docker", "do");
+
+    const ghost = ghostElement();
+    assert.ok(ghost);
+
+    addon.adjustToInput("doc");
+    assert.equal(ghost.textContent, "ker");
+    assert.equal(ghost.style.left, "27px");
+
+    // Backspace below the anchor input — the ghost should shift *left*,
+    // not stay pinned at the show-time anchor column. Pinning would
+    // leave a visual gap between the real cursor and the ghost.
+    addon.adjustToInput("d");
+    assert.equal(ghost.textContent, "ocker");
+    // anchor was cursorX=2 captured at show(); "d" is 1 char below
+    // anchorInputLength=2 → predicted cursor column = 1.
+    assert.equal(ghost.style.left, "9px");
+
+    // Backspace past the anchor back to empty: left is clamped at 0.
+    addon.adjustToInput("");
+    assert.equal(ghost.textContent, "docker");
+    assert.equal(ghost.style.left, "0px");
+  } finally {
+    restoreDocument();
+  }
+});
+
+test("advances the anchor by two cells when a CJK glyph is typed", () => {
+  const restoreDocument = installFakeDocument();
+  const { term, ghostElement } = createFakeTerm();
+  const addon = new GhostTextAddon();
+
+  try {
+    addon.activate(term as never);
+    // Suggestion starts with a CJK char so the prefix-match survives
+    // the next keystroke.
+    addon.show("你好世界", "");
+    const ghost = ghostElement();
+    assert.ok(ghost);
+    // show() anchored at cursorX=2. Input length 0 → delta 0 → left=18.
+    assert.equal(ghost.style.left, "18px");
+
+    addon.adjustToInput("你");
+
+    // One CJK char = 2 cells. Predicted col = 2 + 2 = 4 → left 36px.
+    assert.equal(ghost.textContent, "好世界");
+    assert.equal(ghost.style.left, "36px");
+  } finally {
+    restoreDocument();
+  }
+});
+
+test("wraps the ghost to the next row when the predicted column crosses cols", () => {
+  const restoreDocument = installFakeDocument();
+  const { term, ghostElement } = createFakeTerm();
+  const addon = new GhostTextAddon();
+
+  try {
+    // Shrink the terminal to 10 cols to keep the math obvious. Anchor at
+    // col 8 with 5 ASCII chars to type → predicted col = 13, which should
+    // wrap to col 3 of row 1.
+    term.cols = 10;
+    term.buffer.active.cursorX = 8;
+    addon.activate(term as never);
+    addon.show("abcdefghij", "ab");
+    const ghost = ghostElement();
+    assert.ok(ghost);
+    assert.equal(ghost.style.top, "0px");
+
+    addon.adjustToInput("abcde");
+
+    // Predicted col = 8 + (5-2) = 11 → wraps to col 1 on next row.
+    // cellWidth=9, cellHeight=18.
+    assert.equal(ghost.textContent, "fghij");
+    assert.equal(ghost.style.left, "9px");
+    assert.equal(ghost.style.top, "18px");
+  } finally {
+    restoreDocument();
+  }
+});
+
+test("self-heals a stale anchor on render while no adjustToInput has fired", () => {
+  const restoreDocument = installFakeDocument();
+  const { term, ghostElement, fireRender } = createFakeTerm();
+  const addon = new GhostTextAddon();
+
+  try {
+    addon.activate(term as never);
+    // show() captures cursorX=2 — simulate this firing during the
+    // keystroke→echo gap by later advancing the live cursor and
+    // verifying the ghost anchor snaps to the echoed position.
+    addon.show("docker", "do");
+    const ghost = ghostElement();
+    assert.ok(ghost);
+    assert.equal(ghost.style.left, "18px");
+
+    term.buffer.active.cursorX = 5;
+    fireRender();
+
+    // Input hasn't moved from the show-time baseline, so updatePosition
+    // re-reads live cursor: new left = 5 * 9 = 45px.
+    assert.equal(ghost.style.left, "45px");
+  } finally {
+    restoreDocument();
+  }
+});
+
+test("self-heal adopts live X/Y when echo wraps instead of double-counting", () => {
+  const restoreDocument = installFakeDocument();
+  const { term, ghostElement, fireRender } = createFakeTerm();
+  const addon = new GhostTextAddon();
+
+  try {
+    // Prompt ends at col 8; four pending cells predict X=12 on a 10-col
+    // terminal (wraps to col 2 / row 1). When echo lands there, Math.max
+    // on X alone would keep 12 and paint the ghost on row 2.
+    term.cols = 10;
+    term.buffer.active.cursorX = 8;
+    term.buffer.active.cursorY = 0;
+    term.buffer.active.baseY = 0;
+    term.buffer.active.getLine = () => ({
+      translateToString: () => "$       ",
+    });
+    addon.activate(term as never);
+    addon.show("abcdefghij", "abcd");
+    const ghost = ghostElement();
+    assert.ok(ghost);
+    // Predicted wrap: col 2 on row 1 → left 18px, top 18px.
+    assert.equal(ghost.style.left, "18px");
+    assert.equal(ghost.style.top, "18px");
+
+    term.buffer.active.cursorX = 2;
+    term.buffer.active.cursorY = 1;
+    term.buffer.active.getLine = () => ({
+      isWrapped: true,
+      translateToString: () => "abcd",
+    });
+    fireRender();
+
+    assert.equal(ghost.style.left, "18px");
+    assert.equal(ghost.style.top, "18px");
+  } finally {
+    restoreDocument();
+  }
+});
+
+test("self-heal adopts live X when a bottom-row wrap scrolls instead of changing Y", () => {
+  const restoreDocument = installFakeDocument();
+  const { term, ghostElement, fireRender } = createFakeTerm();
+  const addon = new GhostTextAddon();
+
+  try {
+    // Bottom-row prediction: prompt at col 8 + 4 pending cells → X=12.
+    // Echo scrolls the buffer so Y stays on the last row while live X
+    // becomes the normalized wrap column (2). Math.max would keep 12 and
+    // paint the ghost one row below the visible screen.
+    term.cols = 10;
+    term.rows = 24;
+    term.buffer.active.cursorX = 8;
+    term.buffer.active.cursorY = 23;
+    term.buffer.active.baseY = 0;
+    term.buffer.active.getLine = () => ({
+      translateToString: () => "$       ",
+    });
+    addon.activate(term as never);
+    addon.show("abcdefghij", "abcd");
+    const ghost = ghostElement();
+    assert.ok(ghost);
+    // Pre-echo: col 2 on predicted row 24 → top 24*18.
+    assert.equal(ghost.style.left, "18px");
+    assert.equal(ghost.style.top, "432px");
+
+    term.buffer.active.cursorX = 2;
+    term.buffer.active.cursorY = 23;
+    term.buffer.active.getLine = () => ({
+      isWrapped: true,
+      translateToString: () => "abcd",
+    });
+    fireRender();
+
+    assert.equal(ghost.style.left, "18px");
+    assert.equal(ghost.style.top, "414px");
+  } finally {
+    restoreDocument();
+  }
+});
+
+test("anchors ghost after wide pre-echo input when the line has not echoed yet", () => {
+  const restoreDocument = installFakeDocument();
+  const { term, ghostElement } = createFakeTerm();
+  const addon = new GhostTextAddon();
+
+  try {
+    term.buffer.active.baseY = 0;
+    term.buffer.active.getLine = () => ({
+      translateToString: () => "$ ",
+    });
+    addon.activate(term as never);
+    // Live cursor still at the prompt; typed "部署" is only in the keystroke buffer.
+    addon.show("部署脚本", "部署");
+    const ghost = ghostElement();
+    assert.ok(ghost);
+    assert.equal(ghost.textContent, "脚本");
+    // cursorX=2 + 4 wide cells → column 6 → left 54px.
+    assert.equal(ghost.style.left, "54px");
+  } finally {
+    restoreDocument();
+  }
+});
+
+test("anchors ghost using only the unechoed suffix after a partial shell echo", () => {
+  const restoreDocument = installFakeDocument();
+  const { term, ghostElement } = createFakeTerm();
+  const addon = new GhostTextAddon();
+
+  try {
+    // Shell has echoed "$ doc"; buffered input is still the full "docker".
+    term.buffer.active.cursorX = 5;
+    term.buffer.active.baseY = 0;
+    term.buffer.active.getLine = () => ({
+      translateToString: () => "$ doc",
+    });
+    addon.activate(term as never);
+    addon.show("docker compose", "docker");
+    const ghost = ghostElement();
+    assert.ok(ghost);
+    assert.equal(ghost.textContent, " compose");
+    // Unechoed "ker" is 3 cells → column 8 → left 72px (not 5+6=11).
+    assert.equal(ghost.style.left, "72px");
+  } finally {
+    restoreDocument();
+  }
+});
+
+test("anchors ghost by cell columns when the prompt is a multi-code-unit emoji", () => {
+  const restoreDocument = installFakeDocument();
+  const { term, ghostElement } = createFakeTerm();
+  const addon = new GhostTextAddon();
+
+  try {
+    // Family ZWJ emoji is many UTF-16 units but only 2 terminal cells.
+    // A UTF-16 slice(0, cursorX) would stop inside the emoji and treat the
+    // fully-echoed "docker" as unechoed, shifting the ghost right.
+    const emoji = "👨‍👩‍👧‍👦";
+    const cells: Array<{ chars: string; width: number }> = [
+      { chars: emoji, width: 2 },
+      { chars: " ", width: 1 },
+      { chars: "$", width: 1 },
+      { chars: " ", width: 1 },
+      ...Array.from("docker", (ch) => ({ chars: ch, width: 1 })),
+    ];
+    const totalCols = cells.reduce((sum, cell) => sum + cell.width, 0);
+    term.buffer.active.cursorX = totalCols;
+    term.buffer.active.baseY = 0;
+    term.buffer.active.getLine = () => ({
+      translateToString: (
+        _trimRight?: boolean,
+        startColumn = 0,
+        endColumn = totalCols,
+      ) => {
+        let col = 0;
+        let text = "";
+        for (const cell of cells) {
+          if (col >= endColumn) break;
+          if (col >= startColumn) text += cell.chars;
+          col += cell.width;
+        }
+        return text;
+      },
+    });
+    addon.activate(term as never);
+    addon.show("docker compose", "docker");
+    const ghost = ghostElement();
+    assert.ok(ghost);
+    assert.equal(ghost.textContent, " compose");
+    // Fully echoed → stay at live cursor (11 cells → 99px), not 11+6.
+    assert.equal(ghost.style.left, "99px");
+  } finally {
+    restoreDocument();
+  }
+});
+
+test("does not overshoot the ghost when the echoed command already wrapped", () => {
+  const restoreDocument = installFakeDocument();
+  const { term, ghostElement } = createFakeTerm();
+  const addon = new GhostTextAddon();
+
+  try {
+    // cols=10, prompt "$ " + "docker com" wraps; cursor sits on the
+    // continuation row after a fully-echoed "docker compose".
+    // Physical rows: "$ docker c" | "ompose|"
+    term.cols = 10;
+    term.buffer.active.baseY = 0;
+    term.buffer.active.cursorY = 1;
+    term.buffer.active.cursorX = 6;
+    const lines: Record<number, { isWrapped?: boolean; text: string }> = {
+      0: { text: "$ docker c" },
+      1: { isWrapped: true, text: "ompose" },
+    };
+    term.buffer.active.getLine = (y: number) => {
+      const row = lines[y];
+      if (!row) return undefined;
+      return {
+        isWrapped: row.isWrapped,
+        translateToString: (
+          _trimRight?: boolean,
+          startColumn?: number,
+          endColumn?: number,
+        ) => {
+          if (startColumn !== undefined && endColumn !== undefined) {
+            return row.text.padEnd(endColumn).slice(startColumn, endColumn);
+          }
+          return row.text;
+        },
+      };
+    };
+    addon.activate(term as never);
+    addon.show("docker compose up", "docker compose");
+    const ghost = ghostElement();
+    assert.ok(ghost);
+    assert.equal(ghost.textContent, " up");
+    // Fully echoed across the wrap → anchor stays at live cursor (col 6),
+    // not liveX + full input width.
+    assert.equal(ghost.style.left, "54px");
+    assert.equal(ghost.style.top, "18px");
+  } finally {
+    restoreDocument();
+  }
+});
+
+test("wraps the ghost to the previous row when deletion crosses a row boundary", () => {
+  const restoreDocument = installFakeDocument();
+  const { term, ghostElement } = createFakeTerm();
+  const addon = new GhostTextAddon();
+
+  try {
+    term.cols = 10;
+    term.buffer.active.cursorX = 1;
+    term.buffer.active.cursorY = 1;
+    addon.activate(term as never);
+    // Anchored at row 1 col 1 with 5 chars already typed.
+    addon.show("abcdefghij", "abcde");
+    const ghost = ghostElement();
+    assert.ok(ghost);
+
+    // Backspace back to 2 chars — delta = -3 across a row boundary.
+    addon.adjustToInput("ab");
+
+    // targetCol = 1 - 3 = -2 → col = 8 (wrapped) on row 0.
+    assert.equal(ghost.textContent, "cdefghij");
+    assert.equal(ghost.style.left, "72px");
+    assert.equal(ghost.style.top, "0px");
+  } finally {
+    restoreDocument();
+  }
+});
+
+test("hides ghost immediately when input no longer matches suggestion", () => {
+  const restoreDocument = installFakeDocument();
+  const { term, ghostElement } = createFakeTerm();
+  const addon = new GhostTextAddon();
+
+  try {
+    addon.activate(term as never);
+    addon.show("docker", "do");
+
+    const ghost = ghostElement();
+    assert.ok(ghost);
+    assert.equal(ghost.style.display, "block");
+
+    addon.adjustToInput("dox");
+
+    assert.equal(ghost.style.display, "none");
+    assert.equal(ghost.textContent, "");
+    assert.equal(addon.isActive(), false);
+  } finally {
+    restoreDocument();
+  }
+});
+
+test("applyKeystroke: printable char trims ghost tail when buffer is unreliable (issue #906)", () => {
+  // Repro for issue #906: after Tab passes to shell and the typed-buffer
+  // is flagged unreliable, the ghost addon's currentInput is the only
+  // source of truth for what the user has typed since the last show().
+  // Without applyKeystroke, line 798's reliability gate prevents
+  // adjustToInput from firing and the ghost retains its show-time tail
+  // — when the next keystroke advances the cursor, the stale tail
+  // overlaps the just-typed glyph (e.g., typing 't' after 'systemctl s'
+  // makes the screen read 'systemctl sttop firewalld').
+  const restoreDocument = installFakeDocument();
+  const { term, ghostElement } = createFakeTerm();
+  const addon = new GhostTextAddon();
+
+  try {
+    addon.activate(term as never);
+    addon.show("systemctl stop firewalld", "systemctl s");
+    const ghost = ghostElement();
+    assert.ok(ghost);
+    assert.equal(ghost.textContent, "top firewalld");
+
+    addon.applyKeystroke("t");
+
+    // Ghost tail must shrink by exactly one char so when the shell
+    // echoes 't', the next visible glyph after the cursor is 'o', not
+    // 't' (which would render as 'sttop').
+    assert.equal(ghost.textContent, "op firewalld");
+    assert.equal(addon.isActive(), true);
+  } finally {
+    restoreDocument();
+  }
+});
+
+test("applyKeystroke: backspace re-grows ghost tail by one char", () => {
+  const restoreDocument = installFakeDocument();
+  const { term, ghostElement } = createFakeTerm();
+  const addon = new GhostTextAddon();
+
+  try {
+    addon.activate(term as never);
+    addon.show("docker", "doc");
+    const ghost = ghostElement();
+    assert.ok(ghost);
+    assert.equal(ghost.textContent, "ker");
+
+    addon.applyKeystroke("\x7f");
+
+    assert.equal(ghost.textContent, "cker");
+  } finally {
+    restoreDocument();
+  }
+});
+
+test("applyKeystroke: Ctrl+W word-erases trailing word from currentInput", () => {
+  const restoreDocument = installFakeDocument();
+  const { term, ghostElement } = createFakeTerm();
+  const addon = new GhostTextAddon();
+
+  try {
+    addon.activate(term as never);
+    // Mid-suggestion: user has typed two words; Ctrl+W should drop the
+    // tail word and let the ghost regrow to cover what was erased.
+    addon.show("git commit -m wip", "git com");
+    const ghost = ghostElement();
+    assert.ok(ghost);
+    assert.equal(ghost.textContent, "mit -m wip");
+
+    addon.applyKeystroke("\x17");
+
+    // The same /\s*\S+\s*$/ regex used by handleInput consumes the
+    // leading whitespace too, so "git com" → "git"; the ghost regrows
+    // to cover the now-uncovered leading space + remainder.
+    assert.equal(ghost.textContent, " commit -m wip");
+  } finally {
+    restoreDocument();
+  }
+});
+
+test("applyKeystroke: hides ghost when next char diverges from suggestion", () => {
+  const restoreDocument = installFakeDocument();
+  const { term, ghostElement } = createFakeTerm();
+  const addon = new GhostTextAddon();
+
+  try {
+    addon.activate(term as never);
+    addon.show("docker", "do");
+    const ghost = ghostElement();
+    assert.ok(ghost);
+
+    // 'x' breaks the prefix invariant — ghost must hide immediately so
+    // a → -accept after this point can't pull a stale tail onto a line
+    // that no longer matches the suggestion.
+    addon.applyKeystroke("x");
+
+    assert.equal(ghost.style.display, "none");
+    assert.equal(addon.isActive(), false);
+  } finally {
+    restoreDocument();
+  }
+});
+
+test("applyKeystroke: ignores non-typing data (escape sequences, control codes)", () => {
+  // Escape sequences and other control codes are routed through
+  // clearState() in handleInput, not propagated to the ghost — but we
+  // want applyKeystroke to be a safe no-op if accidentally called with
+  // them (defense in depth).
+  const restoreDocument = installFakeDocument();
+  const { term, ghostElement } = createFakeTerm();
+  const addon = new GhostTextAddon();
+
+  try {
+    addon.activate(term as never);
+    addon.show("docker", "do");
+    const ghost = ghostElement();
+    assert.ok(ghost);
+    const tailBefore = ghost.textContent;
+
+    addon.applyKeystroke("\x1b[A"); // up-arrow escape sequence
+    addon.applyKeystroke("\x01");    // Ctrl+A
+    addon.applyKeystroke("");         // empty
+
+    assert.equal(ghost.textContent, tailBefore);
+    assert.equal(addon.isActive(), true);
+  } finally {
+    restoreDocument();
+  }
+});
+
+test("hides the ghost on render when the device echoed untracked input (#1013)", () => {
+  const restoreDocument = installFakeDocument();
+  const { term, ghostElement, fireRender } = createFakeTerm();
+  const addon = new GhostTextAddon();
+
+  try {
+    addon.activate(term as never);
+    // We believe only "network in" is typed; suggestion is the full command.
+    addon.show("network interface show", "network in");
+    assert.equal(addon.isActive(), true);
+
+    // The real line shows MORE than we tracked: a bastion host echoed the
+    // next char ("t") that our client-side buffer never recorded.
+    const line = "ecOS# network int";
+    const active = term.buffer.active as Record<string, unknown>;
+    active.baseY = 0;
+    active.cursorX = line.length;
+    active.getLine = () => ({ translateToString: () => line });
+
+    fireRender();
+
+    assert.equal(addon.isActive(), false);
+    assert.equal(ghostElement()?.style.display, "none");
+  } finally {
+    addon.dispose();
+    restoreDocument();
+  }
+});
+
+test("hides the ghost when TopsecOS-style backspace leaves stale text after the cursor (#1060)", () => {
+  const restoreDocument = installFakeDocument();
+  const { term, ghostElement, fireRender } = createFakeTerm();
+  const addon = new GhostTextAddon();
+
+  try {
+    addon.activate(term as never);
+    // The user deleted back from "system..." to "syst", so the tracked
+    // input is shorter and the ghost regrows to "em license show".
+    addon.show("system license show", "syst");
+    assert.equal(addon.isActive(), true);
+
+    // TopsecOS devices shown in #1060 leave the old suffix visible after
+    // the cursor while processing Backspace, so the real buffer looks like:
+    // TopsecOS# syst|em license show
+    const beforeCursor = "TopsecOS# syst";
+    const line = `${beforeCursor}em license show`;
+    const active = term.buffer.active as Record<string, unknown>;
+    active.baseY = 0;
+    active.cursorX = beforeCursor.length;
+    active.getLine = () => ({ translateToString: () => line });
+
+    fireRender();
+
+    assert.equal(addon.isActive(), false);
+    assert.equal(ghostElement()?.style.display, "none");
+  } finally {
+    addon.dispose();
+    restoreDocument();
+  }
+});
+
+test("hides the ghost when only the deleted prefix remains after the cursor (#1060)", () => {
+  const restoreDocument = installFakeDocument();
+  const { term, ghostElement, fireRender } = createFakeTerm();
+  const addon = new GhostTextAddon();
+
+  try {
+    addon.activate(term as never);
+    addon.show("system license show", "syst");
+    assert.equal(addon.isActive(), true);
+
+    const beforeCursor = "TopsecOS# syst";
+    const active = term.buffer.active as Record<string, unknown>;
+    active.baseY = 0;
+    active.cursorX = beforeCursor.length;
+    active.getLine = () => ({ translateToString: () => `${beforeCursor}em` });
+
+    fireRender();
+
+    assert.equal(addon.isActive(), false);
+    assert.equal(ghostElement()?.style.display, "none");
+  } finally {
+    addon.dispose();
+    restoreDocument();
+  }
+});
+
+test("hides the ghost when TopsecOS-style backspace leaves stale text after empty input (#1060)", () => {
+  const restoreDocument = installFakeDocument();
+  const { term, ghostElement, fireRender } = createFakeTerm();
+  const addon = new GhostTextAddon();
+
+  try {
+    addon.activate(term as never);
+    addon.show("system license show", "");
+    assert.equal(addon.isActive(), true);
+
+    const beforeCursor = "TopsecOS# ";
+    const active = term.buffer.active as Record<string, unknown>;
+    active.baseY = 0;
+    active.cursorX = beforeCursor.length;
+    active.getLine = () => ({ translateToString: () => `${beforeCursor}system license show` });
+
+    fireRender();
+
+    assert.equal(addon.isActive(), false);
+    assert.equal(ghostElement()?.style.display, "none");
+  } finally {
+    addon.dispose();
+    restoreDocument();
+  }
+});
+
+test("hides the ghost when stale text is followed by right-side status text (#1060)", () => {
+  const restoreDocument = installFakeDocument();
+  const { term, ghostElement, fireRender } = createFakeTerm();
+  const addon = new GhostTextAddon();
+
+  try {
+    addon.activate(term as never);
+    addon.show("system license show", "syst");
+    assert.equal(addon.isActive(), true);
+
+    const beforeCursor = "TopsecOS# syst";
+    const active = term.buffer.active as Record<string, unknown>;
+    active.baseY = 0;
+    active.cursorX = beforeCursor.length;
+    active.getLine = () => ({ translateToString: () => `${beforeCursor}em     12:34 ok` });
+
+    fireRender();
+
+    assert.equal(addon.isActive(), false);
+    assert.equal(ghostElement()?.style.display, "none");
+  } finally {
+    addon.dispose();
+    restoreDocument();
+  }
+});
+
+test("hides the ghost when a stale argument suffix starts with a space (#1060)", () => {
+  const restoreDocument = installFakeDocument();
+  const { term, ghostElement, fireRender } = createFakeTerm();
+  const addon = new GhostTextAddon();
+
+  try {
+    addon.activate(term as never);
+    addon.show("system license show", "system");
+    assert.equal(addon.isActive(), true);
+
+    const beforeCursor = "TopsecOS# system";
+    const active = term.buffer.active as Record<string, unknown>;
+    active.baseY = 0;
+    active.cursorX = beforeCursor.length;
+    active.getLine = () => ({ translateToString: () => `${beforeCursor} license show` });
+
+    fireRender();
+
+    assert.equal(addon.isActive(), false);
+    assert.equal(ghostElement()?.style.display, "none");
+  } finally {
+    addon.dispose();
+    restoreDocument();
+  }
+});
+
+test("keeps the ghost when unrelated right-side prompt text is visible", () => {
+  const restoreDocument = installFakeDocument();
+  const { term, ghostElement, fireRender } = createFakeTerm();
+  const addon = new GhostTextAddon();
+
+  try {
+    addon.activate(term as never);
+    addon.show("system license show", "syst");
+    assert.equal(addon.isActive(), true);
+
+    const beforeCursor = "host# syst";
+    const active = term.buffer.active as Record<string, unknown>;
+    active.baseY = 0;
+    active.cursorX = beforeCursor.length;
+    active.getLine = () => ({ translateToString: () => `${beforeCursor}     12:34 ok` });
+
+    fireRender();
+
+    assert.equal(addon.isActive(), true);
+    assert.notEqual(ghostElement()?.style.display, "none");
+  } finally {
+    addon.dispose();
+    restoreDocument();
+  }
+});
+
+test("keeps the ghost when only right-side spacing overlaps a space-prefixed suffix", () => {
+  const restoreDocument = installFakeDocument();
+  const { term, ghostElement, fireRender } = createFakeTerm();
+  const addon = new GhostTextAddon();
+
+  try {
+    addon.activate(term as never);
+    addon.show("system license show", "system");
+    assert.equal(addon.isActive(), true);
+
+    const beforeCursor = "host# system";
+    const active = term.buffer.active as Record<string, unknown>;
+    active.baseY = 0;
+    active.cursorX = beforeCursor.length;
+    active.getLine = () => ({ translateToString: () => `${beforeCursor}     12:34 ok` });
+
+    fireRender();
+
+    assert.equal(addon.isActive(), true);
+    assert.notEqual(ghostElement()?.style.display, "none");
+  } finally {
+    addon.dispose();
+    restoreDocument();
+  }
+});
+
+test("keeps the ghost when adjacent right-side text only shares the first character", () => {
+  const restoreDocument = installFakeDocument();
+  const { term, ghostElement, fireRender } = createFakeTerm();
+  const addon = new GhostTextAddon();
+
+  try {
+    addon.activate(term as never);
+    addon.show("system license show", "syst");
+    assert.equal(addon.isActive(), true);
+
+    const beforeCursor = "host# syst";
+    const active = term.buffer.active as Record<string, unknown>;
+    active.baseY = 0;
+    active.cursorX = beforeCursor.length;
+    active.getLine = () => ({ translateToString: () => `${beforeCursor}error` });
+
+    fireRender();
+
+    assert.equal(addon.isActive(), true);
+    assert.notEqual(ghostElement()?.style.display, "none");
+  } finally {
+    addon.dispose();
+    restoreDocument();
+  }
+});