pi-ghost-autocomplete 0.3.2 → 0.5.0

package/dist/ghost-editor.js

@@ -1,1491 +0,0 @@
-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 { 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" });
-export class GhostEditor extends CustomEditor {
-    provider;
-    config;
-    extCtx;
-    metrics;
-    onError;
-    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;
-    lastTextSeen = "";
-    disposed = false;
-    shownMetric = null;
-    recentPaths = new Set();
-    recentPathsAt = 0;
-    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.fastPath.setPathIndex(pathIndex);
-        this.onError = onError;
-        this.profile = profile;
-        this.lastTextSeen = this.getText();
-        this.providerFingerprint = providerFingerprintFromConfig(config.provider);
-    }
-    setPathIndex(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;
-        this.clearGhost();
-    }
-    dispose() {
-        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) {
-        // 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 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;
-        }
-        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();
-        }
-    }
-    /**
-     * 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)
-            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);
-        if (!this.shouldShowGhost())
-            return lines;
-        const ghost = this.ghostText;
-        if (!ghost)
-            return lines;
-        // 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)
-                continue;
-            const idx = line.indexOf(CURSOR_MARKER);
-            if (idx < 0)
-                continue;
-            const before = line.slice(0, idx + CURSOR_MARKER.length);
-            const after = line.slice(idx + CURSOR_MARKER.length);
-            const usedCols = visualWidth(line.slice(0, idx));
-            // Reserve 1 column for cursor, 1 for safety margin.
-            const remaining = width - usedCols - 2;
-            if (remaining <= 0)
-                return lines;
-            const fitted = clipToWidth(display, remaining);
-            if (!fitted)
-                return lines;
-            // Truncate to terminal width – the `after` portion contains padding that was
-            // computed before ghost text insertion, so the combined line can exceed `width`.
-            lines[i] = truncateToWidth(`${before}${DIM_OPEN}${fitted}${DIM_CLOSE}${after}`, width, "");
-            break;
-        }
-        return lines;
-    }
-    cursorAtEnd() {
-        const cursor = this.getCursor();
-        const lines = this.getText().split("\n");
-        if (cursor.line !== lines.length - 1)
-            return false;
-        const last = lines[lines.length - 1] ?? "";
-        return cursor.col >= last.length;
-    }
-    shouldShowGhost() {
-        if (!this.config.enabled)
-            return false;
-        if (!this.ghostText)
-            return false;
-        if (this.isShowingAutocomplete())
-            return false;
-        return this.getText() === this.ghostForText;
-    }
-    clearGhost() {
-        this.cancelInflight();
-        if (this.debounceTimer) {
-            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();
-        }
-    }
-    cancelInflight() {
-        if (this.inflight) {
-            this.inflight.abort();
-            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;
-        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();
-        }
-        if (!this.config.enabled)
-            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();
-        const lastLine = trimmed.split("\n").pop() ?? "";
-        if (stringWidth(lastLine) < this.config.minChars)
-            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;
-        this.debounceTimer = setTimeout(() => {
-            this.debounceTimer = null;
-            void this.requestPrediction(text);
-        }, debounce);
-    }
-    /**
-     * 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 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();
-        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,
-            };
-        }
-        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 before = this.textBeforeCursor(text);
-        const lastLine = before.split("\n").pop() ?? "";
-        if (!lastLine.startsWith("/"))
-            return false;
-        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 (this.isShowingAutocomplete())
-            return false;
-        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;
-        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() {
-        const now = Date.now();
-        if (now - this.recentPathsAt < RECENT_PATHS_TTL_MS)
-            return this.recentPaths;
-        const msgs = getRoleWeightedRecent(this.extCtx, RECENT_USER_MAX, RECENT_ASSISTANT_MAX);
-        this.recentPaths = extractRecentPaths(msgs);
-        this.recentPathsAt = now;
-        return this.recentPaths;
-    }
-    applyDeterministic(text, ghost, replaceFrom, providerName, matchedPath, startedAt) {
-        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: now - startedAt,
-                completion: ghost,
-                matchedPath,
-            };
-        }
-        this.invalidate();
-    }
-    replaceTokenAtCursor(from, replacement) {
-        const cur = this.getCursor();
-        // Deterministic trigger required cursorAtEnd; the token sits at the end
-        // of the current (last) line, so `from.col..cur.col` is the slice to
-        // replace and there is no trailing text to preserve.
-        if (cur.line !== from.line) {
-            // Should not happen given trigger constraints; fall back to append.
-            this.insertTextAtCursor(replacement);
-            return;
-        }
-        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;
-        if (this.getText() !== textAtSchedule)
-            return;
-        const providerAtSchedule = this.provider;
-        const ctrl = new AbortController();
-        this.inflight = ctrl;
-        this.armProvisional({ textAtSchedule, ctrl, provider: providerAtSchedule });
-        const reqCtx = this.buildPredictionContext(textAtSchedule, providerAtSchedule, ctrl);
-        const { pending, beforeAtSchedule, contextFingerprint, cacheKey, reqArgs } = reqCtx;
-        try {
-            // 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,
-            });
-        }
-        catch (err) {
-            if (this.inflight === ctrl)
-                this.inflight = null;
-            const latencyMs = pending ? Date.now() - pending.startedAt : 0;
-            const aborted = err?.name === "AbortError";
-            const trace = providerAtSchedule instanceof RaceProvider ? providerAtSchedule.consumeLastTrace() : null;
-            this.emitMetric(pending, aborted ? "aborted" : "error", undefined, latencyMs, undefined, trace);
-            if (!aborted && this.onError && err instanceof Error) {
-                this.onError(err);
-            }
-        }
-    }
-    /**
-     * 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;
-        // When a race trace exists, trust it verbatim — even an empty
-        // `providers: []` (e.g. cooldown skip) is meaningful: no members ran.
-        // Synthesizing a synthetic ghost-race entry here would otherwise
-        // attribute "empty" results to the race name and skew bench stats.
-        const providers = trace
-            ? trace.providers
-            : [
-                {
-                    provider: pending.providerName,
-                    latencyMs,
-                    result,
-                    rejectionReason,
-                },
-            ];
-        this.metrics.logMetric({
-            ts: Date.now(),
-            requestId: pending.requestId,
-            mode: pending.mode,
-            providers,
-            winner: trace?.winner ?? (result === "produced" ? pending.providerName : undefined),
-            result,
-            rejectionReason,
-            completionLength: completion?.length,
-            shown: false,
-        });
-    }
-    finalizeShown(outcome, regretSnapshot) {
-        const m = this.shownMetric;
-        this.shownMetric = null;
-        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 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())));
-    }
-}
-/**
- * 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
- * `text` with `replacement`. Exported for testability.
- *
- * Caller must guarantee the cursor sits at end of `from.line` and that the
- * replacement is intended to land there; this helper does not validate.
- */
-export function computeReplacement(text, from, replacement) {
-    const lines = text.split("\n");
-    const line = lines[from.line] ?? "";
-    lines[from.line] = line.slice(0, from.col) + replacement;
-    return lines.join("\n");
-}
-/**
- * Visible column width of a possibly-ANSI-colored string.
- * Uses string-width which handles wide chars, combining marks, and emoji.
- */
-export function visualWidth(s) {
-    return stringWidth(stripAnsi(s));
-}
-/**
- * Clip a string to fit in `maxCols` terminal columns, grapheme-aware.
- * Returns the empty string if `maxCols <= 0` or no characters fit.
- */
-export function clipToWidth(s, maxCols) {
-    if (maxCols <= 0)
-        return "";
-    if (stringWidth(s) <= maxCols)
-        return s;
-    let out = "";
-    let used = 0;
-    for (const { segment } of GRAPHEME_SEGMENTER.segment(s)) {
-        const w = stringWidth(segment);
-        if (used + w > maxCols)
-            break;
-        out += segment;
-        used += w;
-    }
-    return out;
-}
-//# sourceMappingURL=ghost-editor.js.map