pi-ghost-autocomplete 0.3.1 → 0.3.2

package/dist/ghost-editor.js

@@ -2,14 +2,78 @@ import { CustomEditor } from "@earendil-works/pi-coding-agent";
 import { CURSOR_MARKER, matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
 import stringWidth from "string-width";
 import stripAnsi from "strip-ansi";
+import { fingerprintProvider, fingerprintRecentMessages, makeKey, } from "./cache.js";
+import { FastPathEngine, decideDeterministic } from "./fast-path-engine.js";
 import { getRecentMessages } from "./context-aggregator.js";
-import { extractFuzzyToken, findFuzzyFilename } from "./fuzzy-matcher.js";
-import { extractPathPrefixToken, findPathPrefix } from "./path-matcher.js";
+import { appendExamples, buildExamplesFromCommit, parseEvalCaptureEnv, } from "./eval-dataset.js";
+import { readContextEnv, selectContext } from "./context-selector.js";
+import { parseToolMaxEnv, summarizeAndCapTools } from "./tool-summarize.js";
+import { containsSensitive, redactSensitive } from "./trie-sanitize.js";
+import { diffStrings as diffEditStrings, editProximityScore as computeEditProximityScore, tokenize as tokenizeEdit, } from "./edit-history-ring.js";
+import { buildShownMetricsRecord } from "./metrics-builder.js";
+import { arm as armRegret, attachToRecord as attachRegret, expire as expireRegret, observe as observeRegret, parseRegretWindowEnv, } from "./regret-tracker.js";
+import { CycleManager } from "./cycle-manager.js";
+// PRD §M3e/f — pure helpers re-exported for back-compat with existing tests
+// that import via the editor module. cycle-manager.ts is the source of truth.
+export { cycleCandidateIdx, nextWordChunk } from "./cycle-manager.js";
+import { rerankCandidateSet } from "./candidate-rerank.js";
 import { RaceProvider } from "./providers/race.js";
+import { wrapAsMulti, wrapAsStream, } from "./providers/types.js";
 import { extractRecentPaths, getRoleWeightedRecent } from "./recent-paths.js";
+import { seedTrieFromCommit } from "./session-trie.js";
+import { KeystrokeTimer } from "./keystroke-timer.js";
+import { combinedVersionFingerprint } from "./versions.js";
 const RECENT_USER_MAX = 2;
 const RECENT_ASSISTANT_MAX = 1;
 const RECENT_PATHS_TTL_MS = 5_000;
+/**
+ * Hover-time threshold for the short-hover-dismiss negative signal (#3).
+ * A ghost dismissed inside this window indicates the user saw it and
+ * actively didn't want it — production systems (Copilot, JetBrains AI)
+ * treat this as soft-negative for ranking/weighting. Tunable via
+ * `PI_GHOST_SHORT_HOVER_MS`.
+ */
+const DEFAULT_SHORT_HOVER_MS = 800;
+/** Trie penalty magnitude on short-hover dismiss. Half the default 0.5
+ *  used for typed-past divergent commits — softer signal. */
+const SHORT_HOVER_TRIE_PENALTY = 0.25;
+/**
+ * Number of consecutive divergent stales on the same line that trips the
+ * typed-past negative signal (#5). At threshold we apply a full-magnitude
+ * trie penalty against the original (prefix, ghost) pair and stamp the
+ * metric record so M8/future weighting can read the signal directly.
+ */
+const TYPED_PAST_DIVERGENT_THRESHOLD = 3;
+/** Trie penalty magnitude on typed-past divergent run — matches the
+ *  "divergent dismiss" baseline documented in `session-trie.ts`. */
+const TYPED_PAST_TRIE_PENALTY = 0.5;
+/**
+ * #5 helper — classify a stale event as divergent or typed-through given
+ * the ghost state at render time and the post-change text. Returns true
+ * when the user typed characters that are NOT a prefix of the suggested
+ * ghost. Pure / exported for testability — the editor wraps this in
+ * `recordDivergentTyped` to track the consecutive run.
+ */
+export function isTypedPastDivergent(ghost, ghostForText, textAfterChange) {
+    if (!ghost)
+        return false;
+    if (!textAfterChange.startsWith(ghostForText))
+        return true;
+    const typedTail = textAfterChange.slice(ghostForText.length);
+    if (typedTail.length === 0)
+        return false;
+    return !ghost.startsWith(typedTail);
+}
+/** Parse `PI_GHOST_SHORT_HOVER_MS`. Falls back to the default on invalid
+ *  or non-positive input. Exposed for tests; called once per dismiss. */
+export function parseShortHoverEnv(raw) {
+    if (raw === undefined)
+        return DEFAULT_SHORT_HOVER_MS;
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n <= 0)
+        return DEFAULT_SHORT_HOVER_MS;
+    return n;
+}
 const DIM_OPEN = "\x1b[2;90m";
 const DIM_CLOSE = "\x1b[0m";
 const GRAPHEME_SEGMENTER = new Intl.Segmenter(undefined, { granularity: "grapheme" });
@@ -19,9 +83,18 @@ export class GhostEditor extends CustomEditor {
     extCtx;
     metrics;
     onError;
-    pathIndex;
+    profile;
     ghostText = null;
     ghostForText = "";
+    keystrokeTimer = new KeystrokeTimer();
+    /**
+     * Tracks consecutive divergent stales on the same line for the #5
+     * typed-past negative signal. Reset by any accept or a non-divergent
+     * (i.e., user-typed-through) stale. Carries the original `(prefix,
+     * ghost)` so a single penalty at threshold can be applied against the
+     * pair that was actually being typed-past.
+     */
+    divergentRun = null;
     ghostReplaceFrom = null;
     debounceTimer = null;
     inflight = null;
@@ -30,18 +103,139 @@ export class GhostEditor extends CustomEditor {
     shownMetric = null;
     recentPaths = new Set();
     recentPathsAt = 0;
-    constructor(tui, theme, keybindings, extCtx, config, provider, metrics = null, pathIndex = null, onError = null) {
+    fastPath = new FastPathEngine();
+    providerFingerprint;
+    versionFingerprint = combinedVersionFingerprint();
+    /** Tracks the prefix shown alongside the current ghost so commit-time
+     *  reconciliation can decide accepted vs divergent. */
+    lastAcceptedGhost = null;
+    /** PRD §M3e/f — CycleManager owns the ranked candidate list, cycling (Alt+]/Alt+[),
+     *  word-level partial accepts (Ctrl+Right), and related accounting. */
+    cycleMgr = new CycleManager();
+    // PRD §M3.5b — provisional ghost manager moved into FastPathEngine
+    // (refactor #57 phase 3). Editor accesses via fastPath.{armProvisional,
+    // reconcileProvisional, isProvisionalShown, cancelProvisionalTimer,
+    // clearProvisional}.
+    /** PRD §M5a — regret detection after accept. Pending while the
+     *  window is open; flushed on regret or deadline. */
+    pendingRegret = null;
+    regretTimer = null;
+    constructor(tui, theme, keybindings, extCtx, config, provider, metrics = null, pathIndex = null, onError = null, profile = null) {
         super(tui, theme, keybindings);
         this.provider = provider;
         this.config = config;
         this.extCtx = extCtx;
         this.metrics = metrics;
-        this.pathIndex = pathIndex;
+        this.fastPath.setPathIndex(pathIndex);
         this.onError = onError;
+        this.profile = profile;
         this.lastTextSeen = this.getText();
+        this.providerFingerprint = providerFingerprintFromConfig(config.provider);
     }
     setPathIndex(index) {
-        this.pathIndex = index;
+        this.fastPath.setPathIndex(index);
+    }
+    setProfile(profile) {
+        this.profile = profile;
+    }
+    /**
+     * PRD §M3g — diagnostic snapshot for the `/ghost` command. Pure read,
+     * no side effects. Numbers are point-in-time; the editor doesn't keep
+     * a running window. `cooldownMs` is reported when the active provider
+     * is a `RaceProvider`; otherwise omitted.
+     */
+    getDiagnostics() {
+        const cache = this.fastPath.cache.stats;
+        const trie = this.fastPath.trie.stats;
+        const ps = this.profile;
+        let profile;
+        if (ps) {
+            const idx = ps.getIndex();
+            profile = {
+                enabled: !ps.disabled,
+                ngrams: idx.ngram.size,
+                paths: idx.path.size,
+                slash: idx.slash.size,
+                accepts: idx.totalAcceptRecords,
+                decayDays: ps.decayDaysSetting,
+            };
+        }
+        else {
+            profile = { enabled: false, ngrams: 0, paths: 0, slash: 0, accepts: 0, decayDays: 0 };
+        }
+        const race = this.provider instanceof RaceProvider
+            ? {
+                cooldown: this.provider.getCooldownState(),
+                members: this.provider.getMemberStats(),
+            }
+            : null;
+        const now = Date.now();
+        const pendingRegret = this.pendingRegret
+            ? {
+                remainingMs: Math.max(0, this.pendingRegret.deadlineMs - now),
+                insertedLen: this.pendingRegret.insertedText.length,
+            }
+            : null;
+        const capabilities = {
+            streaming: typeof this.provider?.predictStream === "function",
+            multiCandidate: typeof this.provider?.predictMulti === "function",
+            preflight: typeof this.provider?.preflight === "function",
+            logprobs: this.provider?.supportsLogprobs === true,
+        };
+        const editHistory = this.buildEditHistoryDiag();
+        return {
+            provider: this.provider?.name ?? null,
+            providerFingerprint: this.providerFingerprint,
+            versionFingerprint: this.versionFingerprint,
+            capabilities,
+            cache,
+            trie,
+            profile,
+            race,
+            ghostShown: this.ghostText !== null,
+            pendingRegret,
+            editHistory,
+        };
+    }
+    /**
+     * Build the edit-history section of `/ghost` diag. Snapshot is taken at
+     * call time; `topAdded` / `topRemoved` expose token *lists only* (no
+     * raw text — privacy contract from spec §6.5).
+     */
+    buildEditHistoryDiag() {
+        const ring = this.fastPath.editHistory;
+        const enabled = this.fastPath.editHistoryEnabled;
+        const events = ring.size;
+        if (events === 0) {
+            return {
+                enabled,
+                events: 0,
+                capacity: ring.capacity,
+                uris: 0,
+                topAdded: [],
+                topRemoved: [],
+                oldestAgeMs: null,
+                halfLifeMs: ring.halfLifeMs,
+            };
+        }
+        const now = Date.now();
+        const snapshot = ring.snapshot(now);
+        const index = ring.index(now);
+        const topK = (m, k) => [...m.entries()]
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, k)
+            .map(([t]) => t);
+        const oldestTs = snapshot.length > 0 ? snapshot[snapshot.length - 1].ts : null;
+        return {
+            enabled,
+            events,
+            capacity: ring.capacity,
+            uris: index.recentUris.size,
+            topAdded: topK(index.addedFreq, 4),
+            topRemoved: topK(index.removedFreq, 4),
+            oldestAgeMs: oldestTs === null ? null : Math.max(0, now - oldestTs),
+            halfLifeMs: ring.halfLifeMs,
+        };
     }
     setProvider(provider) {
         this.provider = provider;
@@ -51,40 +245,263 @@ export class GhostEditor extends CustomEditor {
         this.disposed = true;
         this.finalizeShown("expired");
         this.clearGhost();
+        // Flush any pending regret record BEFORE the metrics logger
+        // drains its queue.
+        this.flushRegret();
         void this.metrics?.flush();
+        void this.profile?.flush();
     }
     handleInput(data) {
-        // Right Arrow accepts the ghost when conditions hold. Use matchesKey so
-        // both legacy CSI/SS3 and Kitty keyboard protocol sequences work.
-        if (matchesKey(data, "right") &&
-            this.ghostText &&
-            !this.isShowingAutocomplete() &&
-            this.cursorAtEnd()) {
-            const accepted = this.ghostText;
-            const replaceFrom = this.ghostReplaceFrom;
-            this.finalizeShown("accepted");
-            this.clearGhost();
-            if (replaceFrom) {
-                this.replaceTokenAtCursor(replaceFrom, accepted);
-            }
-            else {
-                this.insertTextAtCursor(accepted);
+        // Dispatch to focused sub-handlers. Each returns true when it fully
+        // owns the keystroke (no super.handleInput, no text-change observation
+        // needed). Order matters: full accept beats partial-word beats cycle.
+        if (this.handleFullAccept(data))
+            return;
+        if (this.handlePartialWordAccept(data))
+            return;
+        if (this.handleCycle(data))
+            return;
+        this.maybeDismissGhost(data);
+        // Snapshot Enter-committed text BEFORE the base editor clears the
+        // buffer; the post-commit hook fires after super.handleInput drains.
+        const isEnter = matchesKey(data, "enter");
+        const textPreCommit = isEnter ? this.getText().trim() : "";
+        super.handleInput(data);
+        if (isEnter && textPreCommit) {
+            this.onPromptCommitted(textPreCommit);
+        }
+        this.observePostInputTextChange();
+    }
+    /**
+     * Right Arrow → full ghost accept (append-mode appends, replace-mode
+     * replaces the typed token). Seeds the trie + profile with the accepted
+     * (prefix, ghost) pair for append-mode only — replace-mode ghosts are
+     * structurally incompatible with the trie's append model.
+     */
+    handleFullAccept(data) {
+        if (!matchesKey(data, "right") ||
+            !this.ghostText ||
+            this.isShowingAutocomplete() ||
+            !this.cursorAtEnd()) {
+            return false;
+        }
+        const accepted = this.ghostText;
+        const replaceFrom = this.ghostReplaceFrom;
+        // Capture pre-insert snapshot for regret tracking BEFORE we
+        // mutate the buffer. For replace-mode, `textBefore` is the
+        // line slice up to the replacement origin; for append-mode,
+        // it's the entire pre-cursor text.
+        const preInsertText = this.getText();
+        let textBeforeForRegret;
+        if (replaceFrom) {
+            const lines = preInsertText.split("\n");
+            const headLines = lines.slice(0, replaceFrom.line);
+            const partial = (lines[replaceFrom.line] ?? "").slice(0, replaceFrom.col);
+            textBeforeForRegret = [...headLines, partial].join("\n");
+        }
+        else {
+            textBeforeForRegret = preInsertText;
+        }
+        // Seed trie BEFORE finalizeShown clears `shownMetric`. Weight +3 for
+        // full accept (PRD §M2). Replace-mode skipped — its "ghost" REPLACES
+        // a typed token instead of appending, so storing (prefix, ghost)
+        // would yield broken trie suggestions that append the ghost verbatim.
+        if (!replaceFrom) {
+            const prefixForTrie = this.lastSingleLinePrefix();
+            if (prefixForTrie) {
+                this.fastPath.recordAccept(prefixForTrie, accepted, 3);
+                this.lastAcceptedGhost = { prefix: prefixForTrie, ghost: accepted };
+                // PRD §M4 — profile accept capture mirrors the trie seed.
+                this.profile?.captureAccept(prefixForTrie, accepted, 3);
             }
+        }
+        this.finalizeShown("accepted", {
+            textBefore: textBeforeForRegret,
+            insertedText: accepted,
+            textAfter: "",
+        });
+        this.clearGhost();
+        if (replaceFrom) {
+            this.replaceTokenAtCursor(replaceFrom, accepted);
+        }
+        else {
+            this.insertTextAtCursor(accepted);
+        }
+        this.lastTextSeen = this.getText();
+        return true;
+    }
+    /**
+     * PRD §M3f — Ctrl+Right consumes the next word of the ghost.
+     * Append-mode only; replace-mode ghosts (fuzzy/path) accept atomically
+     * via Right. Returns true iff the keystroke was claimed (chunk inserted
+     * or final-chunk path taken). A no-op move (empty chunk) falls through.
+     */
+    handlePartialWordAccept(data) {
+        if (!matchesKey(data, "ctrl+right") ||
+            !this.ghostText ||
+            this.ghostReplaceFrom ||
+            this.isShowingAutocomplete() ||
+            !this.cursorAtEnd()) {
+            return false;
+        }
+        const move = this.cycleMgr.acceptPartialWordAppend();
+        const chunk = move.chunk;
+        if (chunk.length === 0)
+            return false;
+        const remaining = move.remaining;
+        if (remaining === null) {
+            // Last chunk consumes the ghost — record as accepted-partial per
+            // PRD §M5a so analysis can distinguish word-by-word from a single
+            // full Right-Arrow accept. Trie seeding deliberately skipped:
+            // by the final chunk, `ghostText` may be just the last word
+            // (earlier chunks already inserted, `ghostText` shrunk each step)
+            // and `lastSingleLinePrefix()` reflects the post-insert prefix —
+            // neither matches the (prefix, ghost) pair the trie wants.
+            const preInsertText = this.getText();
+            this.finalizeShown("accepted-partial", {
+                textBefore: preInsertText,
+                insertedText: chunk,
+                textAfter: "",
+            });
+            this.clearGhost();
+            this.insertTextAtCursor(chunk);
             this.lastTextSeen = this.getText();
-            return;
+            return true;
+        }
+        // More text remains in the ghost — keep showing the tail.
+        this.insertTextAtCursor(chunk);
+        this.ghostText = remaining;
+        this.ghostForText = this.getText();
+        this.lastTextSeen = this.ghostForText;
+        this.invalidate();
+        return true;
+    }
+    /**
+     * PRD §M3e — Alt+]/Alt+[ cycle through ranked candidates. Append-mode
+     * only and only when more than one candidate exists. Clamp at edges
+     * (no wrap). An edge press is a silent no-op: ghost is preserved
+     * (see `maybeDismissGhost`) and cycledCount is NOT incremented since
+     * the user didn't actually cycle.
+     */
+    handleCycle(data) {
+        const isAltBracket = matchesKey(data, "alt+]") || matchesKey(data, "alt+[");
+        if (!isAltBracket ||
+            !this.ghostText ||
+            this.cycleMgr.candidates.length <= 1 ||
+            this.ghostReplaceFrom ||
+            this.isShowingAutocomplete() ||
+            !this.cursorAtEnd()) {
+            return false;
         }
-        if (this.ghostText && !matchesKey(data, "right")) {
+        const dir = matchesKey(data, "alt+]") ? 1 : -1;
+        if (this.cycleMgr.cycle(dir)) {
+            this.ghostText = this.cycleMgr.current ?? "";
+            // Keep shownMetric.completion in sync with what the user sees so
+            // `completionLength` on the final accept record reflects the
+            // cycled-to candidate, not the originally-displayed one.
+            if (this.shownMetric)
+                this.shownMetric.completion = this.ghostText;
+            this.invalidate();
+        }
+        return true;
+    }
+    /**
+     * Keys we explicitly own preserve the ghost; everything else dismisses.
+     * Alt+]/Alt+[ always preserve (match VS Code: alt+] on a single
+     * candidate is a silent no-op, ghost stays). Ctrl+Right preserves
+     * ONLY in append-mode — for replace-mode (fuzzy/path) ghosts,
+     * Ctrl+Right is normal cursor word-right nav, so the ghost should
+     * dismiss before the parent editor moves the cursor.
+     */
+    maybeDismissGhost(data) {
+        if (!this.ghostText)
+            return;
+        const preservesGhost = matchesKey(data, "right") ||
+            matchesKey(data, "alt+]") ||
+            matchesKey(data, "alt+[") ||
+            (matchesKey(data, "ctrl+right") && !this.ghostReplaceFrom);
+        if (!preservesGhost) {
             this.finalizeShown("dismissed");
             this.clearGhost();
         }
-        super.handleInput(data);
-        // Detect text changes here instead of wrapping `onChange`, so a host
-        // that assigns its own `onChange` after construction never disables us.
+    }
+    /**
+     * Observe post-`super.handleInput` text change: feed the keystroke timer
+     * (single-char insertions only), check pending regret, and dispatch
+     * to `handleTextChange` for the next prediction cycle.
+     */
+    observePostInputTextChange() {
         const text = this.getText();
-        if (text !== this.lastTextSeen) {
-            this.lastTextSeen = text;
-            this.handleTextChange(text);
+        if (text === this.lastTextSeen)
+            return;
+        const prevText = this.lastTextSeen;
+        // PRD §M5 — feed single-character insertions into the keystroke timer
+        // so `estimatedTimeSavedMs` reflects this user's actual typing speed
+        // once warmup completes. Multi-char deltas (paste) and deletes are
+        // ignored — they're not "keystrokes" in the inter-key-time sense
+        // PRD §M5 calibrates against.
+        if (text.length - prevText.length === 1) {
+            this.keystrokeTimer.record(Date.now());
         }
+        this.lastTextSeen = text;
+        this.recordEditEvent(prevText, text);
+        // PRD §M5a — per-keystroke regret check. Runs BEFORE the next
+        // suggestion is requested so a regret flush doesn't race the
+        // re-arm path. The accept that armed the watch installed
+        // `pendingRegret`; we observe against current text.
+        if (this.pendingRegret) {
+            const result = observeRegret(this.pendingRegret, text, Date.now());
+            if (result.flush)
+                this.resolvePendingRegret(result);
+        }
+        this.handleTextChange(text);
+    }
+    /**
+     * Enhancement #1 — capture an edit event into the FastPathEngine's
+     * `EditHistoryRing`. Diffs `prev` vs `next` to derive the minimal
+     * `{added, removed}` slice, sanitizes both sides (event dropped on a
+     * sensitive hit), tokenizes, and records.
+     *
+     * No-op when `PI_GHOST_EDIT_HISTORY=0` (master switch read at engine
+     * construction). Single-buffer URI sentinel `"prompt"` — the editor
+     * owns one document.
+     */
+    recordEditEvent(prev, next) {
+        if (!this.fastPath.editHistoryEnabled)
+            return;
+        const { added, removed } = diffEditStrings(prev, next);
+        if (!added && !removed)
+            return;
+        // SECURITY: pre-sanitize raw added/removed BEFORE tokenization.
+        // Either-side hit drops the event entirely — never store partial
+        // secrets via tokenized-half.
+        if (containsSensitive(added) || containsSensitive(removed))
+            return;
+        const cursor = this.getCursor();
+        this.fastPath.editHistory.record({
+            uri: "prompt",
+            rangeStartLine: cursor.line,
+            addedTokens: tokenizeEdit(added),
+            removedTokens: tokenizeEdit(removed),
+            netCharDelta: added.length - removed.length,
+        });
+    }
+    /**
+     * Build the editProximity scorer bound to the current cursor + a
+     * fresh `EditHistoryIndex` snapshot. Returns `null` when edit-history
+     * is disabled OR the ring is empty (no signal to surface). Captured
+     * per-prediction-cycle so the scorer is consistent across all
+     * candidates in a single rerank.
+     */
+    buildEditProximityScorer() {
+        if (!this.fastPath.editHistoryEnabled)
+            return null;
+        if (this.fastPath.editHistory.size === 0)
+            return null;
+        const index = this.fastPath.editHistory.index();
+        const cursor = this.getCursor();
+        const line = cursor.line;
+        return (text) => computeEditProximityScore(text, index, "prompt", line);
     }
     render(width) {
         const lines = super.render(width);
@@ -93,9 +510,15 @@ export class GhostEditor extends CustomEditor {
         const ghost = this.ghostText;
         if (!ghost)
             return lines;
-        // Replace-mode ghost text doesn't extend the typed token, so prefix with
-        // a marker to signal "Right Arrow replaces what you typed with this".
-        const display = this.ghostReplaceFrom ? `→ ${ghost}` : ghost;
+        // Replace-mode → `→ ` marker. Provisional (local guess while LLM
+        // in-flight) → `◌ ` marker so the user sees this is a fast guess,
+        // not the authoritative LLM result. Both prefixes share the same
+        // dim color via the surrounding DIM_OPEN/DIM_CLOSE wrapper.
+        const display = this.ghostReplaceFrom
+            ? `→ ${ghost}`
+            : this.fastPath.isProvisionalShown()
+                ? `◌ ${ghost}`
+                : ghost;
         for (let i = 0; i < lines.length; i++) {
             const line = lines[i];
             if (!line)
@@ -143,10 +566,13 @@ export class GhostEditor extends CustomEditor {
             clearTimeout(this.debounceTimer);
             this.debounceTimer = null;
         }
+        this.fastPath.cancelProvisionalTimer();
         if (this.ghostText !== null) {
             this.ghostText = null;
             this.ghostForText = "";
             this.ghostReplaceFrom = null;
+            this.cycleMgr.reset();
+            this.fastPath.clearProvisional();
             this.invalidate();
         }
     }
@@ -156,11 +582,54 @@ export class GhostEditor extends CustomEditor {
             this.inflight = null;
         }
     }
+    /**
+     * #5 — track consecutive divergent stales on the same prefix family.
+     * A non-divergent (i.e., typed-through) stale resets the run because
+     * the user was on-track with the suggestion. At threshold we apply a
+     * trie penalty against the original `(prefix, ghost)` and stamp the
+     * current `shownMetric` so the resulting stale record carries the
+     * `typedPastDivergent` flag. Only one penalty per run — the run resets
+     * so a long string of divergent typing doesn't double-charge.
+     */
+    recordDivergentTyped(divergent, prefix, ghost) {
+        if (!divergent) {
+            this.divergentRun = null;
+            return;
+        }
+        const lastLine = prefix.split("\n").pop() ?? "";
+        if (!lastLine || !ghost)
+            return;
+        const run = this.divergentRun;
+        if (run && run.prefix === lastLine && run.ghost === ghost) {
+            run.count++;
+        }
+        else {
+            this.divergentRun = { prefix: lastLine, ghost, count: 1 };
+        }
+        const current = this.divergentRun;
+        if (!current)
+            return;
+        if (current.count === TYPED_PAST_DIVERGENT_THRESHOLD) {
+            this.fastPath.penalize(current.prefix, current.ghost, TYPED_PAST_TRIE_PENALTY);
+            if (this.shownMetric)
+                this.shownMetric.typedPastDivergent = true;
+            this.divergentRun = null;
+        }
+    }
     handleTextChange(text) {
         if (this.disposed)
             return;
-        this.cancelInflight();
         if (this.ghostText && text !== this.ghostForText) {
+            // PRD-adjacent enhancement (#5): typed-past divergent run.
+            // Compute divergent-vs-typed-through BEFORE finalizeShown clears
+            // `shownMetric`. A keystroke is "typed-through" iff the new text
+            // equals `ghostForText + <prefix-of-ghost>` — i.e., the user is
+            // typing the start of what we suggested. Anything else is a
+            // divergent typed-past event and increments the run.
+            const ghost = this.ghostText;
+            const divergent = isTypedPastDivergent(ghost, this.ghostForText, text);
+            const prefixForRun = this.shownMetric?.prefixAtShown ?? this.ghostForText;
+            this.recordDivergentTyped(divergent, prefixForRun, ghost);
             this.finalizeShown("stale");
             this.clearGhost();
         }
@@ -168,8 +637,18 @@ export class GhostEditor extends CustomEditor {
             return;
         if (!this.cursorAtEnd())
             return;
+        // Deterministic path produces stable, source-of-truth ghosts (path
+        // matches from `PathIndex`). Its `shownMetric.cacheKey` is intentionally
+        // undefined → `finalizeShown` skips the cache-evict step. Re-typing a
+        // rejected path-match would re-derive the same result anyway.
         if (this.tryDeterministic(text))
             return;
+        // PRD §M4 — Slash command fast-path runs BEFORE the minChars gate and
+        // the provider check: it's a local lookup that doesn't need an LLM
+        // and benefits users at 1-char prefixes like `/`. The line-length cap
+        // is also unnecessary here — slash commands are short by design.
+        if (this.trySlashFastPath(text))
+            return;
         if (!this.provider)
             return;
         const trimmed = text.trimEnd();
@@ -178,6 +657,30 @@ export class GhostEditor extends CustomEditor {
             return;
         if (stringWidth(lastLine) > this.config.maxLineLength)
             return;
+        // Synchronous fast paths via FastPathEngine: trie, then cache, then
+        // speculative warm. All three serve a ghost without firing the LLM
+        // and without waiting for debounce. Trie comes first — reflects this
+        // user's own confirmed history; only source whose hits cost zero $.
+        const recent = this.buildSelectedContext(this.textBeforeCursor(text));
+        const contextFingerprint = fingerprintRecentMessages(recent);
+        const before = this.textBeforeCursor(text);
+        const cooldownActive = this.provider instanceof RaceProvider
+            ? this.provider.getCooldownState().active
+            : false;
+        const hit = this.fastPath.lookup(before, {
+            contextFingerprint,
+            providerFingerprint: this.providerFingerprint,
+            versionFingerprint: this.versionFingerprint,
+            cooldownActive,
+        });
+        if (hit) {
+            // Cancel any in-flight LLM since its result would overwrite the
+            // ghost we're about to show.
+            this.cancelInflight();
+            this.applyServedGhost(text, before, hit);
+            return;
+        }
+        this.cancelInflight();
         if (this.debounceTimer)
             clearTimeout(this.debounceTimer);
         const debounce = this.provider.debounceMs;
@@ -186,39 +689,194 @@ export class GhostEditor extends CustomEditor {
             void this.requestPrediction(text);
         }, debounce);
     }
-    tryDeterministic(text) {
-        if (!this.pathIndex)
-            return false;
-        if (this.isShowingAutocomplete())
-            return false;
+    /**
+     * Extension host hook: notify the editor that a user prompt has been
+     * committed (Enter pressed, message submitted). Seeds the session trie
+     * with prefix→remainder shingles from the committed text and reconciles
+     * any in-flight accepted ghost against the actual commit (for divergent
+     * dismiss accounting in a future iteration).
+     *
+     * Sanitization happens inside the trie. The hook is safe to call with raw
+     * user text — secrets are filtered before insertion.
+     */
+    onPromptCommitted(text) {
+        const accepted = this.lastAcceptedGhost;
+        this.lastAcceptedGhost = null;
+        seedTrieFromCommit(this.fastPath.trie, text, accepted);
+        // PRD §M4 capture point: emit path/slash/trigram records. Sanitization
+        // happens inside `captureCommit`; sensitive messages drop entirely.
+        this.profile?.captureCommit(text);
+        // PRD §M5a "accept-then-Enter-immediately (not regret)": user
+        // committed the prompt — the accepted suggestion was kept and
+        // sent. Flush the pending record with regret=false regardless of
+        // the post-commit buffer state (which is typically empty and
+        // would otherwise look like a full deletion).
+        this.resolvePendingRegret({ flush: true, regret: false, deletedChars: 0 });
+        // PRD §M5c capture point: emit eval examples for offline replay.
+        // Opt-in via `PI_GHOST_EVAL_CAPTURE=1`; raw prompt + context land on
+        // disk, so off by default. Sanitization runs inside
+        // `buildExamplesFromCommit` (sensitive commits/contexts dropped).
+        if (parseEvalCaptureEnv(this.fastPath.config.evalCaptureRaw)) {
+            const context = renderContextForEval(this.buildSelectedContext(this.lastSingleLinePrefix()));
+            const examples = buildExamplesFromCommit(text, {
+                context,
+                providerFingerprint: this.providerFingerprint,
+                versionFingerprint: this.versionFingerprint,
+                providerName: this.provider?.name ?? "none",
+            });
+            if (examples.length > 0) {
+                void appendExamples(this.extCtx.cwd, examples);
+            }
+        }
+    }
+    /**
+     * Single-line prefix at the cursor, used as the trie key. Stripping
+     * earlier lines keeps trie entries small and keeps "prefix" semantics
+     * consistent across single-line commits vs multi-line edits.
+     */
+    lastSingleLinePrefix() {
+        const cursor = this.getCursor();
+        const lines = this.getText().split("\n");
+        const line = lines[cursor.line] ?? "";
+        return line.slice(0, cursor.col);
+    }
+    /**
+     * Assemble the recent-message context for a prediction. Combines:
+     *  - M6a: opt-in tool entries via `getRecentMessages({ includeTools })`
+     *  - M6c: type-aware summarization + cap on tool count
+     *  - M6b: relevance-pruned selection by BM25 + recency
+     *
+     * Returns oldest-first messages suitable for provider rendering. Sized
+     * by the M6d env knobs; falls back to `config.provider.maxRecentMessages`
+     * when context scanning is effectively disabled.
+     */
+    buildSelectedContext(prefix) {
+        const ctxOpts = readContextEnv();
+        const toolMax = parseToolMaxEnv(this.fastPath.config.contextToolMaxRaw);
+        const includeTools = toolMax > 0;
+        // Pull a wide pool (max scan), then summarize tool entries and pass
+        // through selectContext. Convert newest-first by reversing the
+        // oldest-first output from getRecentMessages.
+        const pool = getRecentMessages(this.extCtx, ctxOpts.maxScan, { includeTools });
+        const summarized = summarizeAndCapTools(pool, toolMax);
+        // `selectContext` expects newest-first input. Reverse before passing in.
+        const newestFirst = [...summarized].reverse();
+        const selected = selectContext(newestFirst, prefix, {
+            maxScan: ctxOpts.maxScan,
+            maxSelected: ctxOpts.maxSelected,
+            maxChars: ctxOpts.maxChars,
+            bm25Weight: ctxOpts.bm25Weight,
+        });
+        // `selectContext` returns oldest-first — directly usable. Apply
+        // SEC-15 redaction to every entry before it leaves the process:
+        // recent messages include tool output that may carry API keys,
+        // JWTs, or other high-entropy secrets pasted into the session.
+        // `redactSensitive` is best-effort — see `trie-sanitize.ts` and
+        // the security review for the threshold caveats.
+        return selected.candidates.map((c) => ({
+            role: c.role,
+            text: redactSensitive(c.text),
+            ...(c.toolName !== undefined ? { toolName: c.toolName } : {}),
+        }));
+    }
+    textBeforeCursor(text) {
         const cursor = this.getCursor();
         const lines = text.split("\n");
-        const lineText = lines[cursor.line] ?? "";
-        const partial = lineText.slice(0, cursor.col);
+        const headLines = lines.slice(0, cursor.line);
+        const partial = (lines[cursor.line] ?? "").slice(0, cursor.col);
+        return [...headLines, partial].join("\n");
+    }
+    applyServedGhost(text, before, warm) {
         const startedAt = Date.now();
-        const recentPaths = this.getRecentPaths();
-        const pathTok = extractPathPrefixToken(partial);
-        if (pathTok) {
-            const m = findPathPrefix(this.pathIndex, pathTok.token, { recentPaths });
-            if (m) {
-                this.applyDeterministic(text, m.suffix, null, "path-prefix", m.match, startedAt);
-                return true;
-            }
+        this.setShownGhost(text, warm.ghost, null);
+        if (this.metrics) {
+            this.shownMetric = {
+                requestId: this.metrics.newRequestId(),
+                startedAt,
+                shownAt: startedAt,
+                providerName: warm.providerName,
+                mode: warm.mode,
+                latencyMs: 0,
+                completion: warm.ghost,
+                cacheKey: warm.cacheKey,
+                prefixAtShown: before,
+            };
         }
-        const fuzTok = extractFuzzyToken(lineText, cursor.col);
-        if (!fuzTok)
+        this.invalidate();
+    }
+    /**
+     * Shared ghost-state mutation used by every "show this ghost now" path
+     * (served, deterministic). Sets the 7 ghost-related fields atomically.
+     * `replaceFrom` is null for append-mode ghosts; non-null for fuzzy/path
+     * replace-mode. Does NOT touch `shownMetric` — callers build that with
+     * source-specific fields.
+     */
+    setShownGhost(text, ghost, replaceFrom) {
+        this.ghostText = ghost;
+        this.ghostForText = text;
+        this.ghostReplaceFrom = replaceFrom;
+        this.cycleMgr.setCandidates([ghost]);
+    }
+    /**
+     * PRD §M4 — slash-command fast-path. Runs before the minChars gate and
+     * before the provider check: profile-local lookup, no LLM, useful even
+     * at 1-char prefixes (`/`). Returns true when a slash-completion was
+     * served. Profile must exist; line must start with `/`.
+     */
+    trySlashFastPath(text) {
+        if (!this.profile)
             return false;
-        const fm = findFuzzyFilename(this.pathIndex, fuzTok.token, { recentPaths });
-        if (!fm)
+        const before = this.textBeforeCursor(text);
+        const lastLine = before.split("\n").pop() ?? "";
+        if (!lastLine.startsWith("/"))
             return false;
-        if (fm.score < 70)
+        const slashHit = this.profile.bestSlashMatch(lastLine);
+        if (!slashHit)
+            return false;
+        const suffix = slashHit.cmd.slice(lastLine.length);
+        if (suffix.length === 0)
+            return false;
+        this.cancelInflight();
+        this.applyServedGhost(text, before, {
+            ghost: suffix,
+            mode: "profile-slash",
+            providerName: "profile-slash",
+            cacheKey: undefined,
+        });
+        return true;
+    }
+    tryDeterministic(text) {
+        const pathIndex = this.fastPath.getPathIndex();
+        if (!pathIndex)
             return false;
-        if (fm.score < 85 && !fuzTok.hasActionTrigger)
+        if (this.isShowingAutocomplete())
             return false;
-        const replaceFrom = fm.replace
-            ? { line: cursor.line, col: fuzTok.startCol }
+        const cursor = this.getCursor();
+        const lines = text.split("\n");
+        const lineText = lines[cursor.line] ?? "";
+        const startedAt = Date.now();
+        // PRD §M4 — pass `profilePathBoost` to both deterministic matchers so
+        // historically-frequent paths break ties between equally-fresh
+        // candidates. Bound by `MAX_PATH_BOOST` (0.2) inside the profile
+        // store; cannot beat subtree/recent signals.
+        //
+        // Capture into a local so a concurrent `setProfile(null)` between
+        // closure construction and invocation can't crash matcher calls.
+        const profile = this.profile;
+        const profileBoost = profile
+            ? (path) => profile.profilePathBoost(path)
             : null;
-        this.applyDeterministic(text, fm.ghost, replaceFrom, bandToProvider(fm.band), fm.match, startedAt);
+        const decision = decideDeterministic({
+            pathIndex,
+            lineText,
+            cursorLine: cursor.line,
+            cursorCol: cursor.col,
+            recentPaths: this.getRecentPaths(),
+            profileBoost,
+        });
+        if (!decision)
+            return false;
+        this.applyDeterministic(text, decision.ghost, decision.replaceFrom, decision.providerName, decision.matchedPath, startedAt);
         return true;
     }
     getRecentPaths() {
@@ -231,17 +889,16 @@ export class GhostEditor extends CustomEditor {
         return this.recentPaths;
     }
     applyDeterministic(text, ghost, replaceFrom, providerName, matchedPath, startedAt) {
-        const latencyMs = Date.now() - startedAt;
-        this.ghostText = ghost;
-        this.ghostForText = text;
-        this.ghostReplaceFrom = replaceFrom;
+        this.setShownGhost(text, ghost, replaceFrom);
         if (this.metrics) {
+            const now = Date.now();
             this.shownMetric = {
                 requestId: this.metrics.newRequestId(),
                 startedAt,
+                shownAt: now,
                 providerName,
                 mode: "deterministic",
-                latencyMs,
+                latencyMs: now - startedAt,
                 completion: ghost,
                 matchedPath,
             };
@@ -260,6 +917,35 @@ export class GhostEditor extends CustomEditor {
         }
         this.setText(computeReplacement(this.getText(), from, replacement));
     }
+    /**
+     * PRD §M3.5b — arm a provisional ghost. Engine owns the timer + env
+     * gate + picker construction (uses its own trie/lastGhosts plus the
+     * supplied profile). Editor supplies the request-scoped `canRender`
+     * predicate and the `onShow` UI mutator — both close over `ctrl` +
+     * `textAtSchedule` so they stay consistent with the in-flight request.
+     */
+    armProvisional(input) {
+        const { textAtSchedule, ctrl, provider } = input;
+        this.fastPath.armProvisional({
+            prefix: textAtSchedule,
+            debounceMs: provider.debounceMs,
+            profile: this.profile,
+            canRender: () => !this.disposed &&
+                this.inflight === ctrl &&
+                !this.ghostText &&
+                this.getText() === textAtSchedule &&
+                this.cursorAtEnd(),
+            onShow: (pick) => {
+                const beforeNow = this.textBeforeCursor(textAtSchedule);
+                this.applyServedGhost(textAtSchedule, beforeNow, {
+                    ghost: pick.text,
+                    mode: "provisional",
+                    providerName: `provisional-${pick.source}`,
+                    cacheKey: undefined,
+                });
+            },
+        });
+    }
     async requestPrediction(textAtSchedule) {
         if (this.disposed || !this.provider)
             return;
@@ -268,60 +954,48 @@ export class GhostEditor extends CustomEditor {
         const providerAtSchedule = this.provider;
         const ctrl = new AbortController();
         this.inflight = ctrl;
-        const pending = this.metrics
-            ? {
-                requestId: this.metrics.newRequestId(),
-                startedAt: Date.now(),
-                providerName: providerAtSchedule.name,
-                mode: "llm",
-            }
-            : null;
+        this.armProvisional({ textAtSchedule, ctrl, provider: providerAtSchedule });
+        const reqCtx = this.buildPredictionContext(textAtSchedule, providerAtSchedule, ctrl);
+        const { pending, beforeAtSchedule, contextFingerprint, cacheKey, reqArgs } = reqCtx;
         try {
-            const recent = getRecentMessages(this.extCtx, this.config.provider.maxRecentMessages);
-            const cursor = this.getCursor();
-            const lines = textAtSchedule.split("\n");
-            const headLines = lines.slice(0, cursor.line);
-            const partial = (lines[cursor.line] ?? "").slice(0, cursor.col);
-            const before = [...headLines, partial].join("\n");
-            const result = await providerAtSchedule.predict({
-                editorText: textAtSchedule,
-                editorTextBeforeCursor: before,
-                recentMessages: recent,
-                cwd: this.extCtx.cwd,
-                signal: ctrl.signal,
+            // PRD §M3.5a — incremental render: paint each chunk as it arrives
+            // so the user sees text growing live. Skipped when a provisional
+            // is active — `decideSwap` reconciles once at stream end and
+            // mid-stream painting would cause repeated visual jumps.
+            //
+            // `shownMetric` is NOT installed mid-stream. A Right-arrow accept
+            // that fires before the stream ends still WORKS visually (inserts
+            // whatever's painted) but produces no shown-metric record.
+            // Acceptable rare case; installing `shownMetric` early would race
+            // with the catch-block's abort path and double-emit on mid-stream
+            // cancel.
+            const provisionalActive = this.fastPath.isProvisionalShown();
+            const canRender = () => !provisionalActive &&
+                this.inflight === ctrl &&
+                !this.disposed &&
+                this.getText() === textAtSchedule &&
+                this.cursorAtEnd();
+            const onChunk = (cumulative) => {
+                if (!canRender())
+                    return;
+                this.ghostText = cumulative;
+                this.ghostForText = textAtSchedule;
+                this.cycleMgr.setCandidates([cumulative]);
+                this.invalidate();
+            };
+            const startedAt = pending?.startedAt ?? Date.now();
+            const { set, ttftMs } = await this.runPredictionPath(providerAtSchedule, reqArgs, startedAt, onChunk);
+            this.finalizeProviderResult({
+                set,
+                ttftMs,
+                pending,
+                ctrl,
+                providerAtSchedule,
+                textAtSchedule,
+                beforeAtSchedule,
+                contextFingerprint,
+                cacheKey,
             });
-            const latencyMs = pending ? Date.now() - pending.startedAt : 0;
-            const trace = providerAtSchedule instanceof RaceProvider ? providerAtSchedule.consumeLastTrace() : null;
-            if (this.inflight !== ctrl) {
-                this.emitMetric(pending, "aborted", undefined, latencyMs, undefined, trace);
-                return;
-            }
-            this.inflight = null;
-            if (this.disposed) {
-                this.emitMetric(pending, "aborted", undefined, latencyMs, undefined, trace);
-                return;
-            }
-            if (this.provider !== providerAtSchedule) {
-                this.emitMetric(pending, "aborted", undefined, latencyMs, undefined, trace);
-                return;
-            }
-            if (this.getText() !== textAtSchedule) {
-                this.emitMetric(pending, "rejected", undefined, latencyMs, "stale-text", trace);
-                return;
-            }
-            if (!result) {
-                this.emitMetric(pending, "empty", undefined, latencyMs, undefined, trace);
-                return;
-            }
-            this.ghostText = result;
-            this.ghostForText = textAtSchedule;
-            if (pending) {
-                pending.completion = result;
-                pending.latencyMs = latencyMs;
-                pending.trace = trace;
-                this.shownMetric = pending;
-            }
-            this.invalidate();
         }
         catch (err) {
             if (this.inflight === ctrl)
@@ -335,6 +1009,238 @@ export class GhostEditor extends CustomEditor {
             }
         }
     }
+    /**
+     * Refresh context + fingerprints + build the provider request bag at
+     * fire-time. Session messages may have arrived during the debounce
+     * window; the cache key we persist must match what the provider actually
+     * sees, otherwise a later identical keystroke would miss its own cached
+     * result. Pure context construction — no LLM call.
+     */
+    buildPredictionContext(textAtSchedule, providerAtSchedule, ctrl) {
+        const recent = this.buildSelectedContext(this.textBeforeCursor(textAtSchedule));
+        const contextFingerprint = fingerprintRecentMessages(recent);
+        const beforeAtSchedule = this.textBeforeCursor(textAtSchedule);
+        const cacheKey = makeKey({
+            prefix: beforeAtSchedule,
+            contextFingerprint,
+            providerFingerprint: this.providerFingerprint,
+            configFingerprint: this.fastPath.getConfigFingerprint(),
+        });
+        const pending = this.metrics
+            ? {
+                requestId: this.metrics.newRequestId(),
+                startedAt: Date.now(),
+                providerName: providerAtSchedule.name,
+                mode: "llm",
+                cacheKey,
+                prefixAtShown: beforeAtSchedule,
+            }
+            : null;
+        const reqArgs = {
+            editorText: textAtSchedule,
+            editorTextBeforeCursor: beforeAtSchedule,
+            recentMessages: recent,
+            cwd: this.extCtx.cwd,
+            signal: ctrl.signal,
+        };
+        return { pending, beforeAtSchedule, contextFingerprint, cacheKey, reqArgs };
+    }
+    /**
+     * Post-provider-call disposition: stamp TTFT, run the post-flight gate,
+     * sanitize empty results, rerank, apply confidence gate, reconcile with
+     * any displayed provisional, and commit. Each early-return emits the
+     * appropriate metric; the happy path lands in `commitDisplayedGhost`.
+     *
+     * Extracted from `requestPrediction` as part of refactor #57 phase 1 so
+     * the orchestrator stays a thin sequence (build → await → finalize).
+     */
+    finalizeProviderResult(input) {
+        const { set, ttftMs, pending, ctrl, providerAtSchedule, textAtSchedule, beforeAtSchedule, contextFingerprint, cacheKey, } = input;
+        if (pending && ttftMs !== undefined)
+            pending.ttftMs = ttftMs;
+        const result = set?.candidates[0]?.text ?? null;
+        const latencyMs = pending ? Date.now() - pending.startedAt : 0;
+        const trace = providerAtSchedule instanceof RaceProvider ? providerAtSchedule.consumeLastTrace() : null;
+        const abortReason = this.postFlightCheck(ctrl, providerAtSchedule, textAtSchedule);
+        if (abortReason === "aborted") {
+            this.emitMetric(pending, "aborted", undefined, latencyMs, undefined, trace);
+            return;
+        }
+        if (abortReason === "stale-text") {
+            this.emitMetric(pending, "rejected", undefined, latencyMs, "stale-text", trace);
+            return;
+        }
+        if (!result || !set) {
+            this.emitMetric(pending, "empty", undefined, latencyMs, undefined, trace);
+            return;
+        }
+        // PRD §M3c / §M3c.1 / §M4 — extracted to `candidate-rerank.ts` for
+        // isolation testing. Confidence gate is opt-in via
+        // `PI_GHOST_MIN_CONFIDENCE`; default preserves "always show top".
+        const profileForRerank = this.profile;
+        const editProximityScorer = this.buildEditProximityScorer();
+        const editHistorySize = this.fastPath.editHistory.size;
+        const reranked = rerankCandidateSet({
+            candidates: set.candidates,
+            providerName: providerAtSchedule.name,
+            prefix: beforeAtSchedule,
+            weightsEnvRaw: this.fastPath.config.rerankWeightsRaw,
+            minConfidenceEnvRaw: this.fastPath.config.minConfidenceRaw,
+            ...(profileForRerank
+                ? { profileBias: (t) => profileForRerank.profileBias(t) }
+                : {}),
+            ...(editProximityScorer ? { editProximityScorer } : {}),
+        });
+        if (reranked.gated) {
+            this.emitMetric(pending, "rejected", undefined, latencyMs, undefined, trace);
+            return;
+        }
+        const { candidateTexts, topText } = reranked;
+        // Enhancement #1 — stash the rerank-time edit-history observability
+        // fields on `pending` so the final shown/accepted record carries
+        // them. Skipped when scorer was disabled (size=0 or env off).
+        if (pending && editProximityScorer) {
+            pending.editProximityScore = reranked.topEditProximityScore;
+            pending.editHistorySize = editHistorySize;
+        }
+        // PRD §M3.5b — reconcile against any displayed provisional. The
+        // reranker's top score (if multi-candidate) feeds the LLM side;
+        // single-candidate sets use a neutral 0.5 since no rerank score
+        // exists. The manager owns timer cancel + state cleanup.
+        const llmScore = set.candidates.length > 1 ? 0.55 : 0.5;
+        const reconciled = this.fastPath.reconcileProvisional({
+            llm: { text: topText, score: llmScore },
+            now: Date.now(),
+        });
+        if (reconciled.hadProvisional && reconciled.decision.action === "keep") {
+            // Provisional was displayed and the LLM lost the swap-margin
+            // check. Keep what's on screen; discard LLM.
+            this.emitMetric(pending, "produced", topText, latencyMs, undefined, trace);
+            return;
+        }
+        // `extend` is the only branch where `decision.text` differs from
+        // `topText` (longer of provisional/LLM). `swap` ⇒ decision.text ===
+        // topText; `keep` ⇒ already returned above; no-provisional `swap`
+        // ⇒ decision.text === topText.
+        const displayText = reconciled.decision.action === "extend" ? reconciled.decision.text : topText;
+        this.commitDisplayedGhost({
+            displayText,
+            candidateTexts,
+            textAtSchedule,
+            beforeAtSchedule,
+            cacheKey,
+            contextFingerprint,
+            providerName: providerAtSchedule.name,
+            pending,
+            latencyMs,
+            trace,
+            displaced: reconciled.displaced,
+        });
+    }
+    /**
+     * Centralized post-provider-call disposition. Returns `null` when the
+     * result is good to render; otherwise the abort reason the caller should
+     * report via `emitMetric`. Clears `this.inflight` only on the happy path
+     * (matches the prior in-line behavior at the first non-aborted check) so
+     * an `aborted` return leaves `inflight` for the catch / next request to
+     * deal with.
+     */
+    postFlightCheck(ctrl, providerAtSchedule, textAtSchedule) {
+        if (this.inflight !== ctrl)
+            return "aborted";
+        this.inflight = null;
+        if (this.disposed)
+            return "aborted";
+        if (this.provider !== providerAtSchedule)
+            return "aborted";
+        if (this.getText() !== textAtSchedule)
+            return "stale-text";
+        return null;
+    }
+    /**
+     * PRD §M3.5a — invoke the provider in either streaming or multi-candidate
+     * mode and (when streaming) drive incremental UI paint via `onChunk`.
+     * Stamps TTFT on the first stream chunk and returns it for the caller to
+     * attach to the pending metric.
+     *
+     * - Streaming path: provider exposes `predictStream` AND lacks
+     *   `predictMulti`. Used by Mercury FIM streaming + LocalProvider.
+     * - Multi path: everything else (openai-compat FIM, race with sync
+     *   members). `onChunk` is ignored.
+     *
+     * Extracted from `requestPrediction` as part of refactor #57 so the
+     * orchestrator stays focused on rerank / reconcile / commit.
+     */
+    async runPredictionPath(provider, reqArgs, startedAt, onChunk) {
+        if (provider.predictStream && !provider.predictMulti) {
+            let ttftMs;
+            let lastCumulative = "";
+            for await (const chunk of wrapAsStream(provider, reqArgs)) {
+                if (chunk.firstChunk && ttftMs === undefined) {
+                    ttftMs = Date.now() - startedAt;
+                }
+                lastCumulative = chunk.cumulative;
+                onChunk(chunk.cumulative);
+            }
+            const set = lastCumulative
+                ? { candidates: [{ text: lastCumulative }] }
+                : null;
+            return ttftMs !== undefined ? { set, ttftMs } : { set };
+        }
+        const set = await wrapAsMulti(provider, reqArgs);
+        return { set };
+    }
+    /**
+     * Commit a successfully-reconciled LLM ghost to all on-screen + fast-path
+     * structures: ranked candidate list, ghost text, cache, speculative ring,
+     * and the pending metric record. Extracted from `requestPrediction` as
+     * part of refactor #57 to keep the orchestrator readable.
+     *
+     * Cache + speculative ring store the *reranked* top — a subsequent cache
+     * hit must reproduce what the user actually saw, not the provider's
+     * pre-rerank order.
+     */
+    commitDisplayedGhost(input) {
+        // PRD §M3e — preserve the full ranked list for cycle keys.
+        this.cycleMgr.setCandidates(input.candidateTexts);
+        this.ghostText = input.displayText;
+        this.ghostForText = input.textAtSchedule;
+        const now = Date.now();
+        const configFingerprint = this.fastPath.getConfigFingerprint();
+        this.fastPath.setCacheEntry(input.cacheKey, {
+            ghost: input.displayText,
+            ts: now,
+            providerFingerprint: this.providerFingerprint,
+            contextFingerprint: input.contextFingerprint,
+            versionFingerprint: this.versionFingerprint,
+            configFingerprint,
+            providerName: input.providerName,
+        });
+        this.fastPath.recordRecentGhost({
+            prefix: input.beforeAtSchedule,
+            ghost: input.displayText,
+            ts: now,
+            contextFingerprint: input.contextFingerprint,
+            providerFingerprint: this.providerFingerprint,
+            versionFingerprint: this.versionFingerprint,
+            configFingerprint,
+            providerName: input.providerName,
+        });
+        if (input.pending) {
+            input.pending.completion = input.displayText;
+            input.pending.latencyMs = input.latencyMs;
+            input.pending.trace = input.trace;
+            input.pending.shownAt = now;
+            if (input.displaced) {
+                input.pending.provisionalSwapMs = input.displaced.provisionalSwapMs;
+                input.pending.provisionalWasCorrect = input.displaced.provisionalWasCorrect;
+                if (input.displaced.swapWasVisualJump)
+                    input.pending.swapRenderedAt = now;
+            }
+            this.shownMetric = input.pending;
+        }
+        this.invalidate();
+    }
     emitMetric(pending, result, completion, latencyMs, rejectionReason, trace) {
         if (!this.metrics || !pending)
             return;
@@ -364,43 +1270,183 @@ export class GhostEditor extends CustomEditor {
             shown: false,
         });
     }
-    finalizeShown(outcome) {
+    finalizeShown(outcome, regretSnapshot) {
         const m = this.shownMetric;
         this.shownMetric = null;
-        if (!this.metrics || !m)
+        if (!m) {
+            // Still need to manage the regret-flush invariant even when there's
+            // no pending metric — the supersede semantics live with the outcome,
+            // not the metric.
+            const isAccept = outcome === "accepted" || outcome === "accepted-partial";
+            if (isAccept && this.pendingRegret)
+                this.flushRegret();
             return;
-        const providers = m.trace
-            ? m.trace.providers
-            : [
-                {
-                    provider: m.providerName,
-                    latencyMs: m.latencyMs ?? 0,
-                    result: "produced",
-                },
-            ];
-        this.metrics.logMetric({
-            ts: Date.now(),
-            requestId: m.requestId,
-            mode: m.mode,
-            providers,
-            winner: m.trace?.winner ?? m.providerName,
-            result: "produced",
-            completionLength: m.completion?.length,
-            shown: true,
-            acceptance: outcome,
-            matchedPath: m.matchedPath,
+        }
+        const snap = this.cycleMgr.snapshot();
+        const built = buildShownMetricsRecord({
+            pending: m,
+            outcome,
+            now: Date.now(),
+            candidateCount: snap.count,
+            candidateIdx: snap.idx,
+            cycledCount: snap.cycled,
+            partialAccepts: snap.partials,
+            msPerChar: this.keystrokeTimer.msPerChar,
+            shortHoverThresholdMs: parseShortHoverEnv(this.fastPath.config.shortHoverMsRaw),
         });
+        // On non-accept outcomes, treat the served ghost as poison for this exact
+        // key so an immediate retype doesn't re-serve the rejected ghost from
+        // cache. Speculative ring stays intact — its match branches are stricter
+        // and not the source of the rejected ghost in the common case.
+        //
+        // Both this and the trie penalty below fire regardless of whether a
+        // `metrics` logger is wired up — they are session-state corrections,
+        // not telemetry. (Pre-slice-3 the trie path was accidentally gated on
+        // `metrics != null`; the new ordering is the intended behavior.)
+        if (built.shouldEvictCache && m.cacheKey)
+            this.fastPath.deleteCacheEntry(m.cacheKey);
+        // Enhancement #3 — short-hover-dismiss trie penalty. Trie keys on the
+        // last single-line slice (matches insert path in `onPromptCommitted`).
+        if (built.shortHoverPenalty) {
+            this.fastPath.penalize(built.shortHoverPenalty.lastLine, built.shortHoverPenalty.completion, SHORT_HOVER_TRIE_PENALTY);
+        }
+        // A new accept supersedes any in-flight regret window from a
+        // previous accept. Flush the prior record before staging this one.
+        // Non-accept outcomes (stale/dismissed/expired) must NOT flush the
+        // prior accept's window — that would cut the regret-detection
+        // window short and miss late regrets within `windowMs`.
+        if (built.isAccept && this.pendingRegret)
+            this.flushRegret();
+        if (!this.metrics)
+            return;
+        const record = built.record;
+        // An accept-outcome resets the divergent-typed run; the user did
+        // converge on a useful suggestion eventually. Non-accept outcomes
+        // leave the run intact so a sequence of stales + a one-off dismiss
+        // inside it still counts toward the threshold.
+        if (built.isAccept)
+            this.divergentRun = null;
+        // PRD §M5a regret window: for accepts, stash the record + arm the
+        // tracker. Actual `logMetric` fires when regret resolves (timer
+        // or detected). Non-accept outcomes log immediately.
+        if (regretSnapshot &&
+            (outcome === "accepted" || outcome === "accepted-partial")) {
+            const windowMs = parseRegretWindowEnv(this.fastPath.config.regretWindowMsRaw);
+            this.pendingRegret = armRegret(record, regretSnapshot, Date.now(), windowMs);
+            this.regretTimer = setTimeout(() => this.flushRegret(), windowMs);
+            return;
+        }
+        this.metrics.logMetric(record);
+    }
+    /**
+     * Detach + clear the pending-regret watch (handle + timer) atomically
+     * and return the captured handle. Callers decide how to resolve the
+     * outcome (`observeRegret`, `expireRegret`, or a forced no-regret on
+     * Enter-commit) and log the resulting record.
+     *
+     * Returns null when no watch was armed — callers can short-circuit.
+     */
+    takePendingRegret() {
+        const h = this.pendingRegret;
+        if (!h)
+            return null;
+        this.pendingRegret = null;
+        if (this.regretTimer) {
+            clearTimeout(this.regretTimer);
+            this.regretTimer = null;
+        }
+        return h;
+    }
+    resolvePendingRegret(outcome) {
+        const h = this.takePendingRegret();
+        if (!h)
+            return;
+        this.metrics?.logMetric(attachRegret(h, outcome));
+    }
+    /**
+     * Flush any pending regret-watched record. Called by the timer, by a
+     * later accept that supersedes the prior window, or by dispose.
+     * Detects regret against the *current* editor text via `expireRegret`
+     * so the final record reflects whatever the user did in the window.
+     */
+    flushRegret() {
+        const h = this.takePendingRegret();
+        if (!h)
+            return;
+        this.metrics?.logMetric(attachRegret(h, expireRegret(h, this.getText())));
     }
 }
-function bandToProvider(band) {
-    switch (band) {
-        case "basename-prefix":
-            return "basename-prefix";
-        case "fuzzy-basename":
-            return "fuzzy-basename";
-        case "fuzzy-path":
-            return "fuzzy-path";
+/**
+ * Render a recent-messages array into a single string for eval capture
+ * (PRD §M5c). Format mirrors the provider context shape — `role: text`
+ * joined by newlines — so a CLI replay can feed it back to the same
+ * provider. Tool entries get a `tool ${name}:` label.
+ */
+export function renderContextForEval(recent) {
+    if (recent.length === 0)
+        return "";
+    const out = [];
+    for (const m of recent) {
+        const label = m.role === "tool" && m.toolName ? `tool ${m.toolName}` : m.role;
+        out.push(`${label}: ${m.text}`);
+    }
+    return out.join("\n");
+}
+/**
+ * Build a stable provider fingerprint from the config. For race configs, fold
+ * each member into the `extras` map so member rotation invalidates cache.
+ */
+export function providerFingerprintFromConfig(cfg) {
+    if (cfg.kind === "race") {
+        const extras = {
+            pauseMs: cfg.pauseMs,
+            cooldownMs: cfg.cooldownMs,
+            cutoffMs: cfg.cutoffMs,
+        };
+        cfg.members.forEach((m, i) => {
+            extras[`m${i}.kind`] = m.kind;
+            extras[`m${i}.model`] = m.modelId;
+            extras[`m${i}.temp`] = m.temperature;
+            extras[`m${i}.maxTokens`] = m.maxTokens;
+            if (m.kind === "openai-compat") {
+                extras[`m${i}.providerName`] = m.providerName;
+                extras[`m${i}.baseUrl`] = m.baseUrl;
+            }
+            else if (m.kind === "local") {
+                extras[`m${i}.baseUrl`] = m.baseUrl;
+            }
+            else if (m.kind === "cloud") {
+                extras[`m${i}.provider`] = m.provider;
+            }
+        });
+        // Note: For race configs, per-member temperature/maxTokens are stored in extras.
+        // These top-level fields are intentional placeholders for fingerprint stability.
+        return fingerprintProvider({
+            kind: "race",
+            providerName: "race",
+            modelId: cfg.members.map((m) => m.modelId).join("|"),
+            temperature: cfg.members[0]?.temperature ?? 0,
+            maxTokens: cfg.members[0]?.maxTokens ?? 0,
+            maxRecentMessages: cfg.maxRecentMessages,
+            extras,
+        });
     }
+    const extras = {};
+    if (cfg.kind === "openai-compat")
+        extras.baseUrl = cfg.baseUrl;
+    else if (cfg.kind === "local")
+        extras.baseUrl = cfg.baseUrl;
+    else if (cfg.kind === "cloud")
+        extras.provider = cfg.provider;
+    return fingerprintProvider({
+        kind: cfg.kind,
+        providerName: cfg.kind === "openai-compat" ? cfg.providerName : cfg.kind,
+        modelId: cfg.modelId,
+        temperature: cfg.temperature,
+        maxTokens: cfg.maxTokens,
+        maxRecentMessages: cfg.maxRecentMessages,
+        extras,
+    });
 }
 /**
  * Pure helper: replace the slice `[from.col, end-of-line]` on `from.line` of