[Init] Initial commit - NetMesh terminal manager

components/terminal/autocomplete/promptDetector.ts

@@ -0,0 +1,973 @@
+/**
+ * Prompt detector for terminal autocomplete.
+ * Detects whether the user is currently at a shell prompt (vs. inside a running program).
+ * Uses xterm.js buffer analysis to identify common prompt patterns.
+ *
+ * Strategy: scan prompt-looking boundaries ($ # % >, Powerline/Nerd Font glyphs,
+ * etc.) and choose the most reliable split for prompt text vs. user input.
+ */
+
+import type { Terminal as XTerm } from "@xterm/xterm";
+import { isSensitiveTerminalChallenge } from "../../../domain/terminalPromptSecurity";
+import { sliceStringByCellColumns } from "./terminalStringCellWidth";
+import { COMMON_SHELL_COMMANDS, NON_PROMPT_PATTERNS, PROMPT_CHARS } from "./promptDetectorPatterns";
+
+export interface PromptDetectionResult {
+  /** Whether a prompt is detected on the current line */
+  isAtPrompt: boolean;
+  /** The detected prompt text (everything before user input) */
+  promptText: string;
+  /** The user's current input (after the prompt) */
+  userInput: string;
+  /** The cursor column position within the user input */
+  cursorOffset: number;
+}
+
+const NO_PROMPT: PromptDetectionResult = {
+  isAtPrompt: false, promptText: "", userInput: "", cursorOffset: 0,
+};
+
+export function isNonPromptLine(lineText: string): boolean {
+  return NON_PROMPT_PATTERNS.some((pattern) => pattern.test(lineText));
+}
+
+function isSpecificShellPromptCandidate(
+  promptText: string,
+  options: { allowGreaterThanTerminator?: boolean } = {},
+): boolean {
+  const trimmed = promptText.trim();
+  if (
+    !options.allowGreaterThanTerminator &&
+    (trimmed.endsWith(">") || trimmed.endsWith("›"))
+  ) {
+    return false;
+  }
+  return trimmed.length >= 6 && /[@:\\/~\])]/.test(trimmed);
+}
+
+function isLikelyNoSpaceShellPromptText(promptText: string): boolean {
+  const trimmed = promptText.trim();
+  if (/^root[#%$]$/.test(trimmed)) return true;
+  if (trimmed.length < 3) return false;
+
+  const marker = trimmed[trimmed.length - 1];
+  if (!PROMPT_CHARS.has(marker) && !isPuaChar(marker)) return false;
+
+  const prev = trimmed[trimmed.length - 2] ?? "";
+  return /[~:/\\\])]/.test(prev);
+}
+
+export interface AlignedPromptResult {
+  /** The prompt view every consumer should use for parsing / suggestion lookup / line rewrites. */
+  prompt: PromptDetectionResult;
+  /**
+   * The keystroke buffer, but only when it's both marked reliable AND
+   * can be validated against the live terminal line. Returns null
+   * otherwise - the single signal downstream uses to decide whether
+   * to record it as the executed command.
+   */
+  alignedTyped: string | null;
+  /**
+   * When false, `prompt.userInput` was filled from the keystroke buffer
+   * before any shell echo. Empty echo is also what echo-disabled password
+   * prompts look like, so callers must not surface or accept completions
+   * (built-in or external) and must not authorize history recording
+   * (`alignedTyped`). Omitted/true means the live line validated input.
+   */
+  allowExternalProviders?: boolean;
+}
+
+function getCursorLinePrefix(term: XTerm): string | null {
+  const buffer = term.buffer.active;
+  const cursorY = buffer.cursorY + buffer.baseY;
+  const line = buffer.getLine(cursorY);
+
+  if (!line) return null;
+
+  const lineText = line.translateToString(false);
+  return sliceStringByCellColumns(lineText, 0, Math.max(0, buffer.cursorX), term);
+}
+
+function getWrappedCursorPrefix(term: XTerm): string | null {
+  const buffer = term.buffer.active;
+  const cursorY = buffer.cursorY + buffer.baseY;
+  const cursorX = buffer.cursorX;
+  const line = buffer.getLine(cursorY);
+
+  if (!line?.isWrapped) return null;
+
+  let promptRow = cursorY - 1;
+  while (promptRow >= 0) {
+    const prevLine = buffer.getLine(promptRow);
+    if (!prevLine) return null;
+    if (!prevLine.isWrapped) break;
+    promptRow--;
+  }
+
+  const promptLine = buffer.getLine(promptRow);
+  if (!promptLine) return null;
+
+  let prefix = promptLine.translateToString(false);
+  for (let row = promptRow + 1; row < cursorY; row++) {
+    const rowLine = buffer.getLine(row);
+    if (!rowLine) return null;
+    prefix += rowLine.translateToString(false);
+  }
+
+  const cursorRowText = line.translateToString(false);
+  return prefix + sliceStringByCellColumns(cursorRowText, 0, Math.max(0, cursorX), term);
+}
+
+function inferPromptTextBeforeTypedInput(
+  cursorPrefix: string,
+  typedBuffer: string,
+  allowPartialEcho: boolean,
+): string | null {
+  if (cursorPrefix.endsWith(typedBuffer)) {
+    const promptText = cursorPrefix.slice(0, cursorPrefix.length - typedBuffer.length);
+    return promptText.length > 0 ? promptText : null;
+  }
+
+  if (!allowPartialEcho) return null;
+
+  const maxEchoLength = Math.min(cursorPrefix.length, typedBuffer.length);
+  const minPartialEchoLength = Math.max(6, typedBuffer.length - 2);
+  for (let echoLength = maxEchoLength - 1; echoLength >= minPartialEchoLength; echoLength--) {
+    const echoedInput = typedBuffer.slice(0, echoLength);
+    if (!cursorPrefix.endsWith(echoedInput)) continue;
+
+    const promptText = cursorPrefix.slice(0, cursorPrefix.length - echoLength);
+    if (promptText.length > 0) return promptText;
+  }
+
+  const noSpacePromptMinEchoLength = typedBuffer.trim().length <= 2 ? 1 : 3;
+  for (
+    let echoLength = Math.min(maxEchoLength - 1, minPartialEchoLength - 1);
+    echoLength >= noSpacePromptMinEchoLength;
+    echoLength--
+  ) {
+    const echoedInput = typedBuffer.slice(0, echoLength);
+    if (!cursorPrefix.endsWith(echoedInput)) continue;
+    const hasReliablePartialEcho =
+      typedBuffer.trim().length <= 2 ||
+      echoedInput.endsWith(" ") ||
+      (echoedInput.includes(" ") && echoedInput.length >= 4);
+    if (!hasReliablePartialEcho) continue;
+
+    const promptText = cursorPrefix.slice(0, cursorPrefix.length - echoLength);
+    if (isLikelyNoSpaceShellPromptText(promptText)) return promptText;
+  }
+
+  return null;
+}
+
+function hasSwallowedCommandAfterPrompt(promptText: string, promptBoundary: number): boolean {
+  const candidate = promptText.slice(0, promptBoundary).trimEnd();
+  const finalIndex = candidate.length - 1;
+  const finalChar = finalIndex >= 0 ? candidate[finalIndex] : "";
+
+  for (let i = 0; i < finalIndex; i++) {
+    const ch = candidate[i];
+    if (!PROMPT_CHARS.has(ch) && !isPuaChar(ch)) continue;
+
+    const nextChar = i + 1 < candidate.length ? candidate[i + 1] : null;
+    if (nextChar === null || nextChar === " ") continue;
+
+    const earlierPrompt = candidate.slice(0, i + 1);
+    if (isLikelyNoSpaceShellPromptText(earlierPrompt)) return true;
+    if (isEmbeddedPromptMarkerAt(candidate, i)) continue;
+    if (!isSpecificShellPromptCandidate(earlierPrompt)) continue;
+    if (PROMPT_CHARS.has(nextChar) || isPuaChar(nextChar)) return true;
+    if (startsWithCommonShellCommand(candidate.slice(i + 1))) return true;
+    if (finalChar !== "$") return true;
+  }
+
+  return false;
+}
+
+function canUseInferredPromptText(promptText: string, rawIsAtPrompt: boolean): boolean {
+  if (promptText.length === 0) return false;
+  if (rawIsAtPrompt) return true;
+
+  const promptBoundary = findPromptBoundary(promptText);
+  const promptEndsAtBoundary =
+    promptBoundary >= 0 && promptText.slice(promptBoundary).trim().length === 0;
+  return (
+    promptEndsAtBoundary &&
+    !hasSwallowedCommandAfterPrompt(promptText, promptBoundary) &&
+    isSpecificShellPromptCandidate(promptText)
+  );
+}
+
+function isThemedPromptText(promptText: string): boolean {
+  for (const ch of promptText) {
+    if (isPuaChar(ch)) return true;
+  }
+  return /[❯❮→➜➤⟩»›]/.test(promptText);
+}
+
+function isPromptPathDecoration(trimmed: string): boolean {
+  return (
+    trimmed === "~" ||
+    trimmed.startsWith("~/") ||
+    trimmed.startsWith("/") ||
+    /^[A-Za-z]:[\\/]/.test(trimmed) ||
+    trimmed.includes("\\")
+  );
+}
+
+function isPromptBareDirectoryText(trimmed: string): boolean {
+  if (trimmed.startsWith("./") || trimmed.startsWith("../")) return false;
+  return /^[\w.-]+$/.test(trimmed);
+}
+
+function isPromptStatusToken(token: string): boolean {
+  return (
+    /^git:\([^)]*\)$/.test(token) ||
+    /^[+$#%>!?*]$/.test(token) ||
+    token === "✗" ||
+    token === "✔"
+  );
+}
+
+function isPromptStatusText(trimmed: string): boolean {
+  const [first = "", ...rest] = trimmed.split(/\s+/);
+  if (rest.length === 0) return false;
+  if (!isPromptBareDirectoryText(first) && !isPromptPathDecoration(first)) return false;
+  return rest.every(isPromptStatusToken);
+}
+
+function isPromptStatusDecoration(extra: string): boolean {
+  if (!/^\s+/.test(extra) || !/\s+$/.test(extra)) return false;
+
+  return isPromptStatusText(extra.trim());
+}
+
+function isPromptDecorationExtra(extra: string, promptText: string): boolean {
+  const trimmed = extra.trim();
+  if (trimmed.length === 0) return false;
+  if (!isThemedPromptText(promptText)) return false;
+  if (startsWithCommonShellCommand(extra)) return false;
+  if (/^\s*\S+\s+$/.test(extra)) {
+    return isPromptPathDecoration(trimmed) || (
+      isPromptBareDirectoryText(trimmed) &&
+      !startsWithCommonShellCommand(trimmed)
+    );
+  }
+  if (isPromptStatusDecoration(extra)) return true;
+  for (const ch of extra) {
+    if (isPuaChar(ch)) return true;
+  }
+  return false;
+}
+
+function getFinalPromptBoundary(promptText: string): number {
+  const trimmedEnd = promptText.trimEnd().length;
+  if (trimmedEnd === 0) return -1;
+
+  const markerIndex = trimmedEnd - 1;
+  const marker = promptText[markerIndex];
+  if (!PROMPT_CHARS.has(marker) && !isPuaChar(marker)) return -1;
+
+  const nextChar = markerIndex + 1 < promptText.length ? promptText[markerIndex + 1] : null;
+  if (nextChar !== null && nextChar !== " ") return -1;
+  return nextChar === " " ? markerIndex + 2 : markerIndex + 1;
+}
+
+function endsAtFinalPromptBoundary(promptText: string): boolean {
+  const promptBoundary = getFinalPromptBoundary(promptText);
+  return promptBoundary >= 0 && promptText.slice(promptBoundary).trim().length === 0;
+}
+
+function getLeadingShellCommandWord(text: string): string | null {
+  return text.trimStart().match(/^[\w.-]+(?=\s|$)/)?.[0] ?? null;
+}
+
+function startsWithCommonShellCommand(text: string): boolean {
+  const command = getLeadingShellCommandWord(text);
+  return command !== null && COMMON_SHELL_COMMANDS.has(command);
+}
+
+function isCompleteSpecificPrompt(promptText: string): boolean {
+  const promptBoundary = getFinalPromptBoundary(promptText);
+  return (
+    promptBoundary >= 0 &&
+    promptText.slice(promptBoundary).trim().length === 0 &&
+    isSpecificShellPromptCandidate(promptText) &&
+    !isEmbeddedPromptMarker(promptText, promptBoundary)
+  );
+}
+
+function looksLikeCommandAfterCompletePrompt(promptText: string, extra: string): boolean {
+  return isCompleteSpecificPrompt(promptText) && extra.trim().length > 0;
+}
+
+function hasShellCommandAfterOptionalDecoration(text: string): boolean {
+  const trimmedStart = text.trimStart();
+  if (startsWithCommonShellCommand(trimmedStart)) return true;
+
+  const [, afterDecoration = ""] = trimmedStart.match(/^\S+\s+(.+)$/) ?? [];
+  return startsWithCommonShellCommand(afterDecoration);
+}
+
+function isSingleBareDirectoryExtra(extra: string): boolean {
+  const trimmed = extra.trim();
+  return /^\s*\S+\s+$/.test(extra) && isPromptBareDirectoryText(trimmed);
+}
+
+function hasExplicitThemedDirectorySpacing(extra: string): boolean {
+  return /^\s+\S+\s+$/.test(extra);
+}
+
+type PromptDecorationReconcileOptions = {
+  allowSingleWordCommandDirectory?: boolean;
+};
+
+function canTreatCommonCommandNameAsThemedDirectory(
+  extra: string,
+  typedInput: string,
+  options: PromptDecorationReconcileOptions = {},
+): boolean {
+  const trimmedInput = typedInput.trim();
+  return (
+    isSingleBareDirectoryExtra(extra) &&
+    (
+      /\s/.test(trimmedInput) ||
+      /^(?:ls|cd|pwd)$/.test(trimmedInput) ||
+      (
+        options.allowSingleWordCommandDirectory === true &&
+        hasExplicitThemedDirectorySpacing(extra)
+      )
+    )
+  );
+}
+
+function canReconcilePromptDecoration(
+  prompt: PromptDetectionResult,
+  typedInput: string,
+  options: PromptDecorationReconcileOptions = {},
+): boolean {
+  if (
+    !prompt.isAtPrompt ||
+    !typedInput ||
+    prompt.userInput.length <= typedInput.length ||
+    !prompt.userInput.endsWith(typedInput)
+  ) {
+    return false;
+  }
+
+  const extra = prompt.userInput.slice(0, prompt.userInput.length - typedInput.length);
+  if (looksLikeCommandAfterCompletePrompt(prompt.promptText, extra)) return false;
+  if (
+    isThemedPromptText(prompt.promptText) &&
+    canTreatCommonCommandNameAsThemedDirectory(extra, typedInput, options)
+  ) {
+    return true;
+  }
+  if (isThemedPromptText(prompt.promptText) && hasShellCommandAfterOptionalDecoration(extra)) {
+    return false;
+  }
+
+  const candidatePromptText = prompt.promptText + extra;
+  const promptEndsAtBoundary =
+    endsAtFinalPromptBoundary(candidatePromptText) &&
+    isSpecificShellPromptCandidate(candidatePromptText);
+  return promptEndsAtBoundary || isPromptDecorationExtra(extra, prompt.promptText);
+}
+
+function alignTypedInputFromCursorPrefix(
+  raw: PromptDetectionResult,
+  cursorPrefix: string | null,
+  typedBuffer: string,
+): AlignedPromptResult | null {
+  if (!cursorPrefix) return null;
+  if (!raw.isAtPrompt && isNonPromptLine(cursorPrefix)) return null;
+
+  const promptText = inferPromptTextBeforeTypedInput(cursorPrefix, typedBuffer, !raw.isAtPrompt);
+  if (!promptText || !canUseInferredPromptText(promptText, raw.isAtPrompt)) {
+    return null;
+  }
+
+  return {
+    prompt: {
+      isAtPrompt: true,
+      promptText,
+      userInput: typedBuffer,
+      cursorOffset: typedBuffer.length,
+    },
+    alignedTyped: typedBuffer,
+  };
+}
+
+function canUseReliablePromptPrefix(
+  raw: PromptDetectionResult,
+  typedBuffer: string,
+): boolean {
+  // Empty echo alone is not validation: echo-disabled prompts can look like
+  // a normal shell PS1 (e.g. `read -s -p '$ '`), and treating the keystroke
+  // buffer as alignedTyped would authorize history recording. Pre-echo
+  // autocomplete uses a separate path that keeps alignedTyped null.
+  if (!raw.isAtPrompt || typedBuffer.length === 0 || raw.userInput.length === 0) {
+    return false;
+  }
+  if (typedBuffer.length <= raw.userInput.length) return false;
+  return isReliableTypedPrefix(raw.userInput, typedBuffer, {
+    allowShortEcho: allowsShortPromptEcho(raw.promptText),
+  });
+}
+
+function isLikelyBareMongoPromptName(promptName: string): boolean {
+  return /^(?:test|admin|local|config)$/i.test(promptName);
+}
+
+function endsWithHostStyleGreaterThanPrompt(promptText: string): boolean {
+  const trimmed = promptText.trimEnd();
+  if (!trimmed.endsWith(">")) return false;
+  const promptName = trimmed.slice(0, -1).trim();
+  return /^[\w.-]+$/.test(promptName) && !isLikelyBareMongoPromptName(promptName);
+}
+
+function endsWithWindowsPathGreaterThanPrompt(promptText: string): boolean {
+  const trimmed = promptText.trimEnd();
+  if (!trimmed.endsWith(">")) return false;
+  const before = trimmed.slice(0, -1).trimEnd();
+  // cmd.exe: `C:\path>` / `C:\>`; PowerShell: `PS C:\path>`
+  if (/^[A-Za-z]:[\\/]/.test(before)) return true;
+  if (/^PS\s+[A-Za-z]:[\\/]/i.test(before)) return true;
+  return false;
+}
+
+function endsWithStandardShellPrompt(promptText: string): boolean {
+  const finalChar = promptText.trimEnd().at(-1);
+  return finalChar === "$" || finalChar === "#" || finalChar === "%";
+}
+
+function allowsShortPromptEcho(promptText: string): boolean {
+  return (
+    endsWithStandardShellPrompt(promptText) ||
+    endsWithHostStyleGreaterThanPrompt(promptText) ||
+    endsWithWindowsPathGreaterThanPrompt(promptText)
+  );
+}
+
+function isReliableTypedPrefix(
+  echoedInput: string,
+  typedBuffer: string,
+  options: { allowShortEcho?: boolean } = {},
+): boolean {
+  if (!typedBuffer.startsWith(echoedInput)) return false;
+  if (
+    options.allowShortEcho &&
+    typedBuffer.trim().length <= 2 &&
+    echoedInput.trim().length >= 1
+  ) {
+    return true;
+  }
+  return (
+    echoedInput.length >= Math.max(4, typedBuffer.length - 2) ||
+    (echoedInput.endsWith(" ") && echoedInput.trim().length >= 2) ||
+    (echoedInput.includes(" ") && echoedInput.length >= 4)
+  );
+}
+
+function withTypedUserInput(
+  prompt: PromptDetectionResult,
+  typedBuffer: string,
+): PromptDetectionResult {
+  return {
+    ...prompt,
+    userInput: typedBuffer,
+    cursorOffset: typedBuffer.length,
+  };
+}
+
+function alignThemedDecorationWithPartialEcho(
+  raw: PromptDetectionResult,
+  typedBuffer: string,
+): AlignedPromptResult | null {
+  if (!raw.isAtPrompt || !isThemedPromptText(raw.promptText)) return null;
+
+  const maxEchoLength = Math.min(raw.userInput.length, typedBuffer.length);
+  for (let echoLength = maxEchoLength; echoLength > 0; echoLength--) {
+    const echoedInput = typedBuffer.slice(0, echoLength);
+    if (!raw.userInput.endsWith(echoedInput)) continue;
+
+    const extra = raw.userInput.slice(0, raw.userInput.length - echoLength);
+    if (extra.length === 0) continue;
+    const hasReliableThemedDirectoryPrefix =
+      isSingleBareDirectoryExtra(extra) &&
+      hasExplicitThemedDirectorySpacing(extra) &&
+      typedBuffer.trim().length <= 3 &&
+      echoedInput.trim().length >= 1;
+
+    const syntheticPrompt = {
+      ...raw,
+      userInput: extra + typedBuffer,
+      cursorOffset: extra.length + typedBuffer.length,
+    };
+    if (
+      !hasReliableThemedDirectoryPrefix &&
+      !isReliableTypedPrefix(echoedInput, typedBuffer)
+    ) {
+      continue;
+    }
+    if (!canReconcilePromptDecoration(syntheticPrompt, typedBuffer, {
+      allowSingleWordCommandDirectory: true,
+    })) continue;
+
+    return {
+      prompt: {
+        isAtPrompt: true,
+        promptText: raw.promptText + extra,
+        userInput: typedBuffer,
+        cursorOffset: typedBuffer.length,
+      },
+      alignedTyped: typedBuffer,
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Detect whether the terminal cursor is at a shell prompt and extract the current user input.
+ */
+export function detectPrompt(term: XTerm): PromptDetectionResult {
+  const buffer = term.buffer.active;
+  const cursorY = buffer.cursorY + buffer.baseY;
+  const cursorX = buffer.cursorX;
+  const line = buffer.getLine(cursorY);
+
+  if (!line) return NO_PROMPT;
+
+  // translateToString(false) preserves trailing spaces — important for cursor-based
+  // input extraction (trailing space triggers empty token for option suggestions)
+  const lineText = line.translateToString(false);
+
+  // Check for non-prompt patterns (pagers, editors, etc.)
+  if (isSensitiveTerminalChallenge(lineText) || isNonPromptLine(lineText)) return NO_PROMPT;
+  if (line.isWrapped) {
+    const wrappedPrefix = getWrappedCursorPrefix(term);
+    if (wrappedPrefix && (isSensitiveTerminalChallenge(wrappedPrefix) || isNonPromptLine(wrappedPrefix))) {
+      return NO_PROMPT;
+    }
+  }
+
+  // Empty line
+  if (lineText.trim().length === 0) return NO_PROMPT;
+
+  // cursorX is a cell column; lineText is characters. Wide glyphs (CJK in a
+  // Windows `C:\Users\用户>` prompt) make substring(cursorX) overshoot into
+  // xterm's empty-cell padding and poison userInput with spaces (#2813 CMD).
+  const cursorLinePrefix = sliceStringByCellColumns(lineText, 0, Math.max(0, cursorX), term);
+  const afterCursor = sliceStringByCellColumns(lineText, Math.max(0, cursorX), undefined, term);
+  // Try to find the prompt boundary on the current line. xterm buffer rows are
+  // padded with blank cells; when the cursor is at the visible row end, scan
+  // only up to the cursor so prompts like "root@host:~#" do not inherit a fake
+  // trailing space. If there is command text to the right of the cursor, keep
+  // the full line so "$" / ">" inside mid-line edits are validated against
+  // their real following character.
+  const promptScanText = afterCursor.trim().length > 0
+    ? lineText
+    : cursorLinePrefix;
+  const promptEnd = findPromptBoundary(promptScanText);
+  if (promptEnd >= 0) {
+    const promptText = lineText.substring(0, promptEnd);
+    // Input is whatever sits between the prompt and the cursor on the cell-
+    // accurate prefix — don't use cursorX as a character index.
+    const userInput = cursorLinePrefix.length >= promptEnd
+      ? cursorLinePrefix.substring(promptEnd)
+      : "";
+    const cursorOffset = userInput.length;
+
+    return { isAtPrompt: true, promptText, userInput, cursorOffset };
+  }
+
+  // Handle wrapped lines: if the prompt is on a previous row (e.g., long path or
+  // long command wrapped onto multiple rows), look upward for the prompt line.
+  // The current row's content is continuation of the command.
+  if (line.isWrapped) {
+    // Walk up to find the first non-wrapped line (the prompt line)
+    let promptRow = cursorY - 1;
+    while (promptRow >= 0) {
+      const prevLine = buffer.getLine(promptRow);
+      if (!prevLine) break;
+      if (!prevLine.isWrapped) break;
+      promptRow--;
+    }
+
+    const promptLine = buffer.getLine(promptRow);
+    if (promptLine) {
+      const promptLineText = promptLine.translateToString(false);
+      if (isSensitiveTerminalChallenge(promptLineText) || isNonPromptLine(promptLineText)) return NO_PROMPT;
+      const pEnd = findPromptBoundary(promptLineText);
+      if (pEnd >= 0) {
+        const promptText = promptLineText.substring(0, pEnd);
+        // Concatenate all rows from promptRow to cursorY to get full input
+        let fullInput = promptLineText.substring(pEnd);
+        for (let row = promptRow + 1; row <= cursorY; row++) {
+          const rowLine = buffer.getLine(row);
+          if (rowLine) fullInput += rowLine.translateToString(false);
+        }
+        // Trim to cursor position on the last row
+        const totalCols = term.cols;
+        const charsBeforeCursorRow = (cursorY - promptRow) * totalCols - pEnd;
+        const userInput = fullInput.substring(0, charsBeforeCursorRow + cursorX);
+        const cursorOffset = userInput.length;
+        if (isSensitiveTerminalChallenge(promptText + userInput)
+          || isNonPromptLine(promptText + userInput)) return NO_PROMPT;
+
+        return { isAtPrompt: true, promptText, userInput, cursorOffset };
+      }
+    }
+  }
+
+  return NO_PROMPT;
+}
+
+/**
+ * Whether a character lives in the Unicode Private Use Area (U+E000–U+F8FF).
+ * Powerline separators (U+E0B0..) and Nerd Font icons (U+E200.., U+F000..) all
+ * fall here. A PUA char followed by a space is common in themed prompt
+ * terminators (oh-my-posh, starship, p10k, etc.), but commands can still echo
+ * those glyphs, so PUA boundaries are kept lower priority than standard prompt
+ * characters and reconciled with the typed buffer when available.
+ */
+function isPuaChar(ch: string): boolean {
+  if (!ch) return false;
+  const code = ch.charCodeAt(0);
+  return code >= 0xE000 && code <= 0xF8FF;
+}
+
+function getBoundaryMarkerIndex(lineText: string, boundary: number): number {
+  if (boundary <= 0) return -1;
+  return lineText[boundary - 1] === " " ? boundary - 2 : boundary - 1;
+}
+
+function isEmbeddedPromptMarkerAt(lineText: string, markerIndex: number): boolean {
+  if (markerIndex <= 0) return false;
+
+  const marker = lineText[markerIndex];
+  if (marker !== "#" && marker !== "%" && marker !== ">" && marker !== "$") return false;
+
+  const prev = lineText[markerIndex - 1];
+  return !/[\s~:\])}]/.test(prev);
+}
+
+function isEmbeddedPromptMarker(lineText: string, boundary: number): boolean {
+  return isEmbeddedPromptMarkerAt(lineText, getBoundaryMarkerIndex(lineText, boundary));
+}
+
+function canSupersedeThemedPromptBoundary(
+  lineText: string,
+  previousBoundary: number,
+  markerIndex: number,
+): boolean {
+  if (!isThemedPromptText(lineText.slice(0, previousBoundary))) return false;
+
+  const rawBetween = lineText.slice(previousBoundary, markerIndex);
+  const between = rawBetween.trim();
+  return (
+    between.length === 0 ||
+    isPromptPathDecoration(between) ||
+    isPromptStatusText(between) ||
+    (
+      /^\s/.test(rawBetween) &&
+      isPromptBareDirectoryText(between)
+    )
+  );
+}
+
+function canPromptMarkerSupersedePreviousBoundary(ch: string): boolean {
+  return ch === "$" || ch === "#" || ch === "%" || ch === ">" || ch === "›";
+}
+
+function isSpacedPromptSegment(lineText: string, boundary: number): boolean {
+  const markerIndex = getBoundaryMarkerIndex(lineText, boundary);
+  if (markerIndex <= 0) return false;
+  if (lineText[markerIndex - 1] !== " ") return false;
+  return lineText[markerIndex + 1] === " ";
+}
+
+/**
+ * Find the boundary between prompt and user input.
+ * Scans left-to-right within the first 200 chars for a prompt character followed by space.
+ * Avoids false positives: $VAR, $(...), ${...} are not prompt endings.
+ * Returns the character index where user input begins, or -1 if no prompt detected.
+ */
+function findPromptBoundary(lineText: string): number {
+  // Scan for prompt boundary. Take the LAST candidate.
+  // For ambiguous chars like >, limit scan to first 60% to avoid matching redirections.
+  // For unambiguous prompt chars ($, #), scan the full line since they're rarely
+  // confused with shell syntax in a prompt position.
+  const lineLen = lineText.trimEnd().length;
+  const scanLimit = Math.min(lineLen, 200);
+  let lastStandardBoundary = -1;
+  let lastPuaBoundary = -1;
+
+  // Ambiguous chars (>) only scan first 60% to avoid matching redirections
+  const ambiguousScanLimit = Math.min(scanLimit, Math.max(40, Math.floor(lineLen * 0.6)));
+
+  for (let i = 0; i < scanLimit; i++) {
+    const ch = lineText[i];
+    const isStandard = PROMPT_CHARS.has(ch);
+    const isPua = !isStandard && isPuaChar(ch);
+
+    if (!isStandard && !isPua) continue;
+
+    // For ambiguous prompt chars like >, only accept in the first 60% of the line
+    if ((ch === ">" || ch === "›") && i >= ambiguousScanLimit) continue;
+    if (
+      (ch === ">" || ch === "›") &&
+      lastStandardBoundary >= 0 &&
+      /\s/.test(lineText.slice(0, i).trim()) &&
+      !isEmbeddedPromptMarker(lineText, lastStandardBoundary) &&
+      !canSupersedeThemedPromptBoundary(lineText, lastStandardBoundary, i)
+    ) {
+      continue;
+    }
+
+    // Must be followed by a space or end-of-line.
+    const nextChar = i + 1 < lineText.length ? lineText[i + 1] : null;
+    if (nextChar !== null && nextChar !== " ") {
+      // Special case: cmd.exe prompt `C:\path>command` — allow > without space
+      // only if preceded by a path-like pattern (drive letter or backslash)
+      if (ch === ">" && i > 1 && (lineText[i - 1] === "\\" || lineText[i - 1] === "/" || /^[A-Za-z]:/.test(lineText))) {
+        // Looks like a path ending — accept as prompt
+      } else {
+        continue;
+      }
+    }
+
+    // For '$': exclude shell variable references ($HOME, $PATH, ${...}, $(...))
+    if (ch === "$") {
+      // Check what comes AFTER the space — but more importantly check what
+      // comes BEFORE to see if this looks like a prompt ending vs mid-command $.
+      // A prompt $ is typically preceded by: space, ), ], digit, username chars, or is at position 0.
+      // A variable $ is typically inside a command: echo $HOME, export PATH=$PATH:...
+      //
+      // Heuristic: if the $ is preceded by a letter/digit/underscore without a space before it
+      // (i.e., it's part of a token like "echo" or "=$PATH"), it's likely a variable.
+      if (i > 0) {
+        const prev = lineText[i - 1];
+        // If preceded by = or / or another non-separator, it's a variable reference
+        if (prev === "=" || prev === "/" || prev === ":") continue;
+        // If preceded by a letter and there's no space between, it could be $HOME-style
+        // But actually: "user@host:~$ " has letter before $. So check if there's
+        // a valid prompt pattern before the $.
+      }
+
+      // Check what follows: if after "$ " there's more content with $ in variable positions
+      // Actually the simplest reliable check: if the character after the space is alphanumeric
+      // or $ or (, this is likely the START of a command (i.e., this $ IS the prompt ending).
+      // That's always true for a prompt. So the $ check is really about false positives mid-line.
+      //
+      // Better heuristic: if we haven't seen a space before this $ (meaning the $ is inside
+      // the first token), it's likely a prompt. If we've already passed spaces (meaning
+      // we're past the first "word"), a $ is more likely a variable.
+      let seenSpaceBeforeDollar = false;
+      for (let j = 0; j < i; j++) {
+        if (lineText[j] === " ") { seenSpaceBeforeDollar = true; break; }
+      }
+      // If there was a space before this $, it might be mid-command (like "echo $HOME")
+      // Only accept if the $ is reasonably close to common prompt patterns
+      if (seenSpaceBeforeDollar) {
+        // Check if this looks like a bracketed prompt ending: "]$ " or ")$ "
+        if (i > 0 && (lineText[i - 1] === "]" || lineText[i - 1] === ")" ||
+            lineText[i - 1] === " " || lineText[i - 1] === "~")) {
+          // Likely a prompt ending like [user@host ~]$
+        } else {
+          continue; // Skip — likely a variable reference mid-command
+        }
+      }
+    }
+
+    // Record this as a candidate boundary. A standard shell prompt terminator
+    // is more reliable than a later Powerline/Nerd Font glyph in command text.
+    const boundary = nextChar === " " ? i + 2 : i + 1;
+    const candidatePromptText = lineText.slice(0, boundary);
+    if (isStandard && hasSwallowedCommandAfterPrompt(candidatePromptText, boundary)) {
+      continue;
+    }
+    if (isStandard && lastStandardBoundary >= 0) {
+      const themedPromptCanSupersede = canSupersedeThemedPromptBoundary(
+        lineText,
+        lastStandardBoundary,
+        getBoundaryMarkerIndex(lineText, boundary),
+      );
+      const canSupersedePreviousBoundary =
+        canPromptMarkerSupersedePreviousBoundary(ch) &&
+        (
+          isEmbeddedPromptMarker(lineText, lastStandardBoundary) ||
+          isSpacedPromptSegment(lineText, lastStandardBoundary) ||
+          themedPromptCanSupersede
+        ) &&
+        (
+          themedPromptCanSupersede ||
+          isSpecificShellPromptCandidate(candidatePromptText, {
+            allowGreaterThanTerminator: ch === ">" || ch === "›",
+          })
+        );
+      if (!canSupersedePreviousBoundary) continue;
+    }
+    if (isStandard) {
+      lastStandardBoundary = boundary;
+    } else {
+      lastPuaBoundary = boundary;
+    }
+  }
+
+  return lastStandardBoundary >= 0 ? lastStandardBoundary : lastPuaBoundary;
+}
+
+/**
+ * Reconcile a buffer-parsed prompt with the user's own keystroke history.
+ *
+ * findPromptBoundary stops at the first `PROMPT_CHAR + space` it sees, so
+ * themes that render additional content after the prompt char — e.g.
+ * oh-my-zsh's robbyrussell prints "➜  ~ " where `~` is the cwd — get
+ * parsed as prompt="➜ " + userInput="~ lo". Every consumer downstream
+ * (history recording, suggestion matching, insertion) then treats the
+ * theme's cwd marker as part of the user's command, which pollutes
+ * history with entries like "~ sudo id" and makes Tab insertions prepend
+ * a phantom "~ " to the typed command (issue #806).
+ *
+ * Whenever we have an independent record of what the user actually typed
+ * since the last Enter (keystroke buffer), we can detect this case: the
+ * real input is always a suffix of the over-captured userInput. When it
+ * is, reattribute the leading garbage back to promptText so the rest of
+ * the pipeline sees the clean split.
+ */
+export function reconcilePromptWithTypedInput(
+  prompt: PromptDetectionResult,
+  typedInput: string,
+): PromptDetectionResult {
+  if (!prompt.isAtPrompt) return prompt;
+  if (!typedInput) return prompt;
+  if (prompt.userInput === typedInput) return prompt;
+  if (
+    prompt.userInput.length > typedInput.length &&
+    prompt.userInput.endsWith(typedInput)
+  ) {
+    if (!canReconcilePromptDecoration(prompt, typedInput, {
+      allowSingleWordCommandDirectory: true,
+    })) {
+      return prompt;
+    }
+    const extra = prompt.userInput.slice(0, prompt.userInput.length - typedInput.length);
+    return {
+      isAtPrompt: true,
+      promptText: prompt.promptText + extra,
+      userInput: typedInput,
+      cursorOffset: typedInput.length,
+    };
+  }
+  return prompt;
+}
+
+export function reconcilePromptWithExternalCommand(
+  prompt: PromptDetectionResult,
+  command: string,
+): PromptDetectionResult | null {
+  const typedInput = command.trim();
+  if (!prompt.isAtPrompt || typedInput.length === 0) return null;
+
+  const syntheticPrompt = {
+    ...prompt,
+    userInput: `${prompt.userInput}${typedInput}`,
+    cursorOffset: prompt.userInput.length + typedInput.length,
+  };
+  if (!canReconcilePromptDecoration(syntheticPrompt, typedInput, {
+    allowSingleWordCommandDirectory: true,
+  })) {
+    return null;
+  }
+
+  const extra = syntheticPrompt.userInput.slice(
+    0,
+    syntheticPrompt.userInput.length - typedInput.length,
+  );
+  return {
+    isAtPrompt: true,
+    promptText: prompt.promptText + extra,
+    userInput: typedInput,
+    cursorOffset: typedInput.length,
+  };
+}
+
+/**
+ * Unified entry point for any autocomplete code path that needs a prompt
+ * view. Every consumer (fetchSuggestions, insertSuggestion,
+ * handleSubDirSelect, Enter-record) goes through this one helper so the
+ * alignment policy lives in exactly one place — if another out-of-band
+ * line-rewrite path gets added later and forgets to notify the keystroke
+ * buffer, the worst that happens is reconcile no-ops and we degrade to
+ * pre-#806 behavior, not a worse pollution.
+ *
+ * Alignment rule: the keystroke buffer is usable only when it's marked
+ * reliable and it can be reconciled with the live line. Exact raw
+ * matches are safe, over-captured prompt chrome can be moved back into
+ * promptText, and no-space prompts can be inferred from the cursor line
+ * when the inferred prompt still looks like a shell prompt. Otherwise
+ * the buffer is ignored and the raw detector result passes through.
+ */
+export function getAlignedPrompt(
+  term: XTerm | null,
+  typedBuffer: string,
+  typedReliable: boolean,
+): AlignedPromptResult {
+  if (!term) return { prompt: NO_PROMPT, alignedTyped: null };
+  const raw = detectPrompt(term);
+  if (!typedReliable || typedBuffer.length === 0) {
+    return { prompt: raw, alignedTyped: null };
+  }
+
+  if (raw.isAtPrompt) {
+    if (raw.userInput === typedBuffer) {
+      return { prompt: raw, alignedTyped: typedBuffer };
+    }
+    if (raw.userInput.length > typedBuffer.length && raw.userInput.endsWith(typedBuffer)) {
+      const prompt = reconcilePromptWithTypedInput(raw, typedBuffer);
+      if (prompt === raw) return { prompt: raw, alignedTyped: null };
+      return {
+        prompt,
+        alignedTyped: typedBuffer,
+      };
+    }
+    const themedDecorationAlignment = alignThemedDecorationWithPartialEcho(raw, typedBuffer);
+    if (themedDecorationAlignment) return themedDecorationAlignment;
+    if (canUseReliablePromptPrefix(raw, typedBuffer)) {
+      return {
+        prompt: withTypedUserInput(raw, typedBuffer),
+        alignedTyped: typedBuffer,
+      };
+    }
+    // No echo yet (CJK IME / high-latency SSH): surface the keystroke buffer
+    // on prompts detectPrompt already recognizes (#2813), but do not set
+    // alignedTyped. Empty / whitespace-only echo is also what echo-disabled
+    // password prompts and padded themed PS1s look like, so this path must
+    // not authorize history recording, built-in suggestion acceptance, or
+    // third-party completion providers until echo validates the line.
+    if (
+      raw.userInput.trim().length === 0 &&
+      (allowsShortPromptEcho(raw.promptText) || isThemedPromptText(raw.promptText))
+    ) {
+      return {
+        prompt: withTypedUserInput(raw, typedBuffer),
+        alignedTyped: null,
+        allowExternalProviders: false,
+      };
+    }
+  }
+
+  const cursorPrefixCandidates = [
+    getWrappedCursorPrefix(term),
+    getCursorLinePrefix(term),
+  ];
+  for (const cursorPrefix of cursorPrefixCandidates) {
+    const aligned = alignTypedInputFromCursorPrefix(raw, cursorPrefix, typedBuffer);
+    if (aligned) return aligned;
+  }
+
+  return { prompt: raw, alignedTyped: null };
+}