@atlaskit/editor-plugin-autocomplete 9.0.0 → 9.2.0

package/src/pm-plugins/autocomplete-plugin.ts

@@ -1,8 +1,10 @@
 import { ACTION, ACTION_SUBJECT, EVENT_TYPE } from '@atlaskit/editor-common/analytics';
+import type { CompletionSource } from '@atlaskit/editor-common/analytics';
 import { logException } from '@atlaskit/editor-common/monitoring';
 import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
 import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
 import { keydownHandler } from '@atlaskit/editor-prosemirror/keymap';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
 import { PluginKey } from '@atlaskit/editor-prosemirror/state';
 import type {
 	EditorState,
@@ -21,6 +23,9 @@ import {
 	isAutocompleteDebugVerbose,
 } from './debug-mode';
 import { createGhostTextDecorationSet } from './ghost-text-decoration';
+// Type-only, so the harvester chunk is still reached exclusively through the
+// dynamic import in `ensureInlineCodeHarvester`.
+import type { HarvestMatch } from './inline-code-harvester';
 import {
 	createLocalSlowLaneClient,
 	type LocalSlowLaneClient,
@@ -38,13 +43,17 @@ import {
 } from './slow-lane-client';
 import {
 	predict,
+	type CtcAbstainReason,
 	type PredictionResult,
 	loadDefaultVocabulary,
 	loadVectorsAsync,
 	incrementSessionFreq,
 	ingestDocumentPage,
 	getLastPredictionDebug,
+	getLastPredictionOutcome,
+	isSurfaceInAcceptCooldown,
 	noteSuggestionAccepted,
+	resetSessionBoosts,
 } from './text-predictor';
 
 export const autocompletePluginKey: PluginKey = new PluginKey('autocomplete');
@@ -58,6 +67,33 @@ const CONTEXT_REFRESH_THROTTLE_MS = 1000;
 // version of the (potentially hundreds-of-KB) page content for the plugin's
 // lifetime. Eviction is FIFO; a re-ingest of an evicted text is harmless.
 const MAX_INGESTED_CONTEXT_TEXTS = 50;
+// Re-prime callback of every mounted editor. The harvested set and the L1
+// boosts are shared by all of them, and more than one is mounted routinely — a
+// comment box alongside its replies, or a comment box alongside the chat input.
+// Membership doubles as the mount count, so a teardown only clears the shared
+// stores once the last editor has gone.
+//
+// Decision: one pot, shared across hosts. Terms harvested in a comment box can
+// be offered in the chat input and the other way round. Both are content from
+// the page the reader is looking at, so the mixing is between things they can
+// already see; partitioning the boosts would mean a per-host overlay on every
+// trie node, which the scoring path reads on every keystroke.
+const mountedEditors = new Set<() => void>();
+// The scope that shared learning belongs to, as last reported by a host that
+// scopes its context. Held here rather than per editor because the data it
+// guards is shared and some hosts replace one editor with another across a
+// navigation: an instance-local key would read as unset on exactly the change it
+// exists to catch, while the previous scope's terms carried on in these globals.
+// Undefined until a scoping host says otherwise. An editor that sends no key
+// still shares the pot being emptied, so it is re-primed from the context it
+// already holds rather than left with learning it can no longer see.
+let contextScopeKey: string | undefined;
+type InlineCodeHarvesterModule = typeof import('./inline-code-harvester');
+// Set by whichever editor first finished importing the harvester chunk. The
+// reset paths go through this rather than their own copy, because the editor
+// that has to clear the set is not always one that imported it — the set is one
+// per module, and nothing can be in it unless some editor got this far.
+let loadedInlineCodeHarvester: InlineCodeHarvesterModule | null = null;
 // Caps how many times the word-boundary path will retry getContext() while the
 // parent comment is still missing. Combined with the 1s throttle this gives a
 // ~5s window to cover a still-loading comment thread, then stops permanently so
@@ -117,6 +153,17 @@ export interface CommittedSuggestion {
 	posterior: number;
 	/** Final confidence-v2 ranking score. */
 	rankScore: number;
+	/**
+	 * Characters of already-typed prefix the insertion overwrites, for surfaces
+	 * that carry their own casing.
+	 *
+	 * The scored path appends its tail and leaves what the user typed alone,
+	 * which is right for prose. A harvested identifier is matched
+	 * case-insensitively but is only correct in the casing it was written in, so
+	 * accepting `ml-s` against `ML-Studio` has to replace rather than append.
+	 * Absent on every other path.
+	 */
+	replacesTypedPrefixLength?: number;
 	/** Monotonic editor decision revision that owns this suggestion. */
 	revision: number;
 	/** How many scored candidates this surface's normaliser divided between. */
@@ -202,8 +249,17 @@ const advanceGhostThroughTypedCharacter = (
 		ghostPosition: nextPosition,
 		decorationSet: createGhostTextDecorationSet(tr.doc, nextPosition, remaining),
 		// `surface` stays the full candidate so cooldown and analytics still
-		// describe the suggestion that was originally committed.
-		suggestion: { ...suggestion, ghostText: remaining, position: nextPosition },
+		// describe the suggestion that was originally committed. The replaced
+		// prefix grows with the keystroke: it is the run the insertion overwrites,
+		// and the user has just typed one more character of it.
+		suggestion: {
+			...suggestion,
+			ghostText: remaining,
+			position: nextPosition,
+			...(suggestion.replacesTypedPrefixLength === undefined
+				? {}
+				: { replacesTypedPrefixLength: suggestion.replacesTypedPrefixLength + 1 }),
+		},
 	};
 };
 
@@ -244,8 +300,11 @@ const getTextBeforeCursor = (state: EditorState): string => {
 	return fullText.slice(-maxChars);
 };
 
+const getTrailingSurfaceToken = (text: string): string =>
+	text.trimEnd().match(TRAILING_SURFACE_PREFIX_REGEX)?.[0] ?? '';
+
 const getTrailingSurfacePrefixLength = (text: string): number =>
-	text.trimEnd().match(TRAILING_SURFACE_PREFIX_REGEX)?.[0].length ?? 0;
+	getTrailingSurfaceToken(text).length;
 
 /**
  * Set the autocomplete state via a transaction metadata.
@@ -268,10 +327,12 @@ const showGhostText = (
 	position: number,
 	revision: number,
 	decisionStartedAt: number,
+	replacesTypedPrefixLength?: number,
 ): CommittedSuggestion | null => {
 	try {
 		const { state, dispatch } = view;
 		const suggestion: CommittedSuggestion = {
+			...(replacesTypedPrefixLength === undefined ? {} : { replacesTypedPrefixLength }),
 			decisionLatencyMs: performance.now() - decisionStartedAt,
 			evidenceTier: prediction.evidenceTier,
 			ghostText: prediction.text,
@@ -342,7 +403,30 @@ const acceptGhostText = (
 	if (dispatch) {
 		try {
 			const { ghostText, ghostPosition, suggestion } = pluginState;
-			let tr = state.tr.insertText(ghostText, ghostPosition);
+			// Replacing back over the typed prefix rewrites it in the surface's own
+			// casing; every other path appends and leaves the prefix untouched.
+			const replaceFrom = Math.max(
+				0,
+				ghostPosition - Math.min(suggestion.replacesTypedPrefixLength ?? 0, ghostPosition),
+			);
+			let tr = state.tr;
+			if (replaceFrom === ghostPosition) {
+				tr = tr.insertText(ghostText, ghostPosition);
+			} else {
+				tr = tr.insertText(suggestion.surface, replaceFrom, ghostPosition);
+				// Only the harvested path replaces, and what authorized it was the
+				// surface being marked as code somewhere in the session. Inserting it
+				// as plain text loses that, so the identifier the user accepted reads
+				// as prose while the same identifier they typed by hand does not.
+				const codeMark = state.schema.marks.code;
+				if (codeMark) {
+					tr = tr.addMark(replaceFrom, replaceFrom + suggestion.surface.length, codeMark.create());
+					// The backtick input rule never ran, so nothing else will close this
+					// mark. Without dropping it from the stored set the next character
+					// the user types continues the code span.
+					tr = tr.removeStoredMark(codeMark);
+				}
+			}
 			tr = setAutocompleteMeta(tr, {
 				ghostText: '',
 				ghostPosition: -1,
@@ -381,6 +465,21 @@ const acceptGhostTextWithAnalytics = (
  * priority boost.
  */
 export interface AutocompleteContext {
+	/**
+	 * Identifies what this context belongs to, for hosts whose editor outlives
+	 * the thing it is writing about — a chat input that stays mounted across
+	 * conversations and pages, say.
+	 *
+	 * When it changes, everything learned for the previous scope is dropped:
+	 * both the L1 boosts and the harvested inline-code set are claims about what
+	 * is being discussed, and neither transfers. The context reported alongside
+	 * the new key is then ingested as if it were the first, so anything still
+	 * current — an ongoing transcript, for instance — is primed again.
+	 *
+	 * Omit it and nothing resets; the editor learns for its own lifetime, which
+	 * is right for a host mounted per comment or per page.
+	 */
+	contextScopeKey?: string;
 	/** Full page content as a string (e.g. markdown). */
 	fullPageContent?: string;
 	/** The currently selected text on the page, if any. */
@@ -397,6 +496,17 @@ export interface AutocompletePluginOptions {
 	 * word-frequency boosting. Called lazily so the preset can remain synchronous.
 	 */
 	getContext?: () => Promise<AutocompleteContext | undefined>;
+	/**
+	 * Opt in to suggesting inline-code identifiers seen in this session
+	 * (`ml-studio` and friends), which no vocabulary holds and the scored path
+	 * therefore cannot reach.
+	 *
+	 * Off by default and passed only by hosts whose own experiment enrolment
+	 * covers it, so a surface that shares this plugin under a different gate is
+	 * unaffected until it opts in too. The harvester is a separate chunk and is
+	 * not requested at all while this is false.
+	 */
+	harvestInlineCode?: boolean;
 	/**
 	 * User locale used to determine whether autocomplete should run.
 	 * Defaults to browser locale when omitted.
@@ -490,6 +600,69 @@ const getLeadingTextCharacter = (text?: string): string | undefined => {
 	return String.fromCodePoint(firstCodePoint);
 };
 
+/**
+ * The one verdict a harvested surface may speak on.
+ *
+ * `no-candidate` is the only abstention that means no vocabulary reaches the
+ * prefix at all. Every other one — a margin the model cannot clear, a rival
+ * still being read — describes known words in contention, where a session
+ * surface with no score behind it would be overruling the ranker rather than
+ * filling a gap it left.
+ */
+const HARVEST_ELIGIBLE_ABSTAIN_REASON: CtcAbstainReason = 'no-candidate';
+
+/**
+ * Whether the scored path has finished with this exact prefix and found nothing.
+ *
+ * The 100ms deadline expiring is not the same answer: it means the ranker was
+ * still working, and displaying then would race a suggestion that is about to
+ * arrive. So the harvest path reads the recorded verdict rather than the clock.
+ */
+const scoredPathFinishedEmpty = (textBefore: string): boolean => {
+	const outcome = getLastPredictionOutcome();
+	return (
+		outcome !== null &&
+		outcome.textBefore === textBefore &&
+		!outcome.awaitingAsyncEvidence &&
+		outcome.abstainReason === HARVEST_ELIGIBLE_ABSTAIN_REASON
+	);
+};
+
+/**
+ * Whether the surface is already sitting immediately before the typed prefix.
+ *
+ * Completing `ml-s` to `ml-studio` right after `ml-studio` produces the echo the
+ * scored path's repetition guard exists to stop, and this path does not go
+ * through arbitration to inherit it.
+ */
+const repeatsPrecedingText = (match: HarvestMatch, textBefore: string): boolean => {
+	const trimmed = textBefore.trimEnd();
+	const preceding = trimmed.slice(0, trimmed.length - match.typedPrefixLength).trimEnd();
+	return preceding.toLowerCase().endsWith(match.surface.toLowerCase());
+};
+
+/**
+ * Dress a harvested match as a prediction so it commits through the same path as
+ * a scored one.
+ *
+ * The scoring fields are zeroed rather than invented: there is no posterior, no
+ * margin and no shortlist behind this surface, and `session-harvest` on the
+ * evidence tier is what says so wherever the snapshot is read.
+ */
+const buildHarvestPrediction = (match: HarvestMatch): PredictionResult => ({
+	evidenceDepth: { totalChars: 0, totalTokens: 0, verifiedChars: 0, verifiedTokens: 0 },
+	evidenceTier: 'session-harvest',
+	meanTokenLogProbability: 0,
+	poolHeldExtension: false,
+	posterior: 0,
+	rankScore: 0,
+	shortlistSize: 0,
+	surface: match.surface,
+	termType: 'word',
+	text: match.ghostText,
+	winnerMargin: 0,
+});
+
 const isEnglishLocale = (locale?: string): boolean => {
 	if (!locale) {
 		return false;
@@ -506,6 +679,7 @@ export const createAutocompletePlugin = (
 	const locale =
 		options?.locale ?? (typeof navigator !== 'undefined' ? navigator.language : undefined);
 	const isAutocompleteEnabled = isEnglishLocale(locale);
+	const isInlineCodeHarvestEnabled = isAutocompleteEnabled && options?.harvestInlineCode === true;
 
 	let debounceTimer: ReturnType<typeof setTimeout> | null = null;
 	let decisionDeadlineTimer: ReturnType<typeof setTimeout> | null = null;
@@ -543,19 +717,33 @@ export const createAutocompletePlugin = (
 	 * server → server slow-lane API returned the context vector
 	 * localLlm → on-device WebGPU/MLC model returned the context vector
 	 */
-	const getCompletionSource = (): 'cold' | 'server' | 'localLlm' => {
+	const getCompletionSource = (): CompletionSource => {
 		if (!slowLaneClient.getContextVector()) {
 			return 'cold';
 		}
 		return options?.useLocalModel ? 'localLlm' : 'server';
 	};
 
-	const fireSuggestionDismissedAnalytics = (reason: 'escape' | 'blur' | 'click'): void => {
+	/**
+	 * Which path produced a given suggestion.
+	 *
+	 * A harvested surface is reported as `harvest` rather than by the slow-lane
+	 * state it happened to be shown under, so its views and acceptances stay
+	 * separable from the scored path's and cannot quietly move the headline
+	 * acceptance rate.
+	 */
+	const completionSourceFor = (suggestion: CommittedSuggestion | null): CompletionSource =>
+		suggestion?.evidenceTier === 'session-harvest' ? 'harvest' : getCompletionSource();
+
+	const fireSuggestionDismissedAnalytics = (
+		reason: 'escape' | 'blur' | 'click',
+		suggestion: CommittedSuggestion | null,
+	): void => {
 		api?.analytics?.actions.fireAnalyticsEvent({
 			action: ACTION.SUGGESTION_DISMISSED,
 			actionSubject: ACTION_SUBJECT.CONTEXTUAL_TYPEAHEAD,
 			eventType: EVENT_TYPE.TRACK,
-			attributes: { completionSource: getCompletionSource(), reason, surface },
+			attributes: { completionSource: completionSourceFor(suggestion), reason, surface },
 		});
 	};
 
@@ -608,7 +796,7 @@ export const createAutocompletePlugin = (
 			actionSubject: ACTION_SUBJECT.CONTEXTUAL_TYPEAHEAD,
 			eventType: EVENT_TYPE.TRACK,
 			attributes: {
-				completionSource: getCompletionSource(),
+				completionSource: completionSourceFor(suggestion),
 				suggestionLength,
 				typedLength,
 				kssDelta,
@@ -662,6 +850,10 @@ export const createAutocompletePlugin = (
 	);
 
 	let contextRequestInFlight = false;
+	// A read the host asked for while another was open, kept so it can be made
+	// once that one settles. One slot, not a queue: a burst of notifications only
+	// ever means "read again", and the last of them describes the current state.
+	let queuedContextRefreshSource: string | undefined;
 	let lastContextRefreshAt = 0;
 	// Bounds the word-boundary retry loop so it terminates even when the editor is
 	// not in a comment thread (parentCommentContent never resolves).
@@ -669,7 +861,154 @@ export const createAutocompletePlugin = (
 	// Set when the plugin is torn down so in-flight getContext() resolutions don't
 	// mutate the global text-predictor state after destruction.
 	let destroyed = false;
-	const ingestedContextTexts = new Set<string>();
+	// L1 ingestion cannot run before the vocabulary has loaded: `incrementSessionFreq`
+	// only touches trie nodes that already exist, so an empty trie silently rejects
+	// every word. Text that arrives first — which a page usually does, since the
+	// chat resolves it on focus in the same tick as the load starts — is held here
+	// and applied once the load has settled.
+	const pendingSessionContextTexts = new Set<string>();
+	const sessionIngestedContextTexts = new Set<string>();
+	let isVocabularyReady = false;
+	let vocabularyLoadPromise: Promise<void> | undefined;
+
+	// Context text waiting on the harvester chunk, the vocabulary, or both. The
+	// harvester drops surfaces the vocabulary already holds, so intake before the
+	// load has settled would admit ordinary words no one needs completed.
+	const pendingHarvestTexts = new Set<string>();
+	// Separate from `sessionIngestedContextTexts` because the two consumers settle
+	// at different times: reply occurrences accumulate, so text fed twice would
+	// count twice.
+	const harvestedContextTexts = new Set<string>();
+	let inlineCodeHarvester: InlineCodeHarvesterModule | null = null;
+	let inlineCodeHarvesterPromise: Promise<InlineCodeHarvesterModule | null> | undefined;
+
+	const addBoundedContextText = (texts: Set<string>, text: string): void => {
+		texts.add(text);
+		// Evict oldest entries (Set preserves insertion order) to bound memory.
+		while (texts.size > MAX_INGESTED_CONTEXT_TEXTS) {
+			const oldest = texts.values().next().value;
+			if (oldest === undefined) {
+				break;
+			}
+			texts.delete(oldest);
+		}
+	};
+
+	const flushPendingSessionContext = (): void => {
+		if (!isVocabularyReady || destroyed) {
+			return;
+		}
+		for (const text of pendingSessionContextTexts) {
+			if (!sessionIngestedContextTexts.has(text)) {
+				ingestDocumentPage(text);
+				addBoundedContextText(sessionIngestedContextTexts, text);
+			}
+			pendingSessionContextTexts.delete(text);
+		}
+	};
+
+	const flushPendingHarvestTexts = (): void => {
+		const harvester = inlineCodeHarvester;
+		if (!harvester || !isVocabularyReady || destroyed || pendingHarvestTexts.size === 0) {
+			return;
+		}
+		for (const text of pendingHarvestTexts) {
+			if (!harvestedContextTexts.has(text)) {
+				harvester.harvestInlineCodeFromText(text);
+				addBoundedContextText(harvestedContextTexts, text);
+			}
+			pendingHarvestTexts.delete(text);
+		}
+		harvester.logInlineCodeHarvest('context');
+	};
+
+	/**
+	 * Load the harvester chunk, once, and only for a host that asked for it.
+	 *
+	 * Kept off the critical path in the same way the vocabulary and vector loads
+	 * are: nothing is requested until the editor is focused, so a session that
+	 * never types in the chat pays nothing for the feature.
+	 */
+	const ensureInlineCodeHarvester = (): Promise<InlineCodeHarvesterModule | null> => {
+		if (!isInlineCodeHarvestEnabled || destroyed) {
+			return Promise.resolve(null);
+		}
+		inlineCodeHarvesterPromise ??= import(
+			/* webpackChunkName: "@atlaskit-internal_editor-plugin-autocomplete-inline-code-harvester" */
+			'./inline-code-harvester'
+		)
+			.then((module) => {
+				if (destroyed) {
+					return null;
+				}
+				inlineCodeHarvester = module;
+				loadedInlineCodeHarvester = module;
+				flushPendingHarvestTexts();
+				return module;
+			})
+			.catch((error) => {
+				// Clear the promise so a later focus can retry; the queued text is
+				// still held and is fed by whichever attempt succeeds.
+				inlineCodeHarvesterPromise = undefined;
+				logException(error as Error, {
+					location: 'editor-plugin-autocomplete/loadInlineCodeHarvester',
+				});
+				return null;
+			});
+		return inlineCodeHarvesterPromise;
+	};
+
+	/**
+	 * Re-read the document's code-marked spans.
+	 *
+	 * The backtick input rule consumes both delimiters on the closing tick, so a
+	 * finished span in the live document is only findable through its mark — and
+	 * only by walking, since a mark carries no notification.
+	 */
+	const harvestDocument = (doc: PMNode, trigger: string): void => {
+		if (!isInlineCodeHarvestEnabled || destroyed) {
+			return;
+		}
+		const harvester = inlineCodeHarvester;
+		if (!harvester) {
+			void ensureInlineCodeHarvester();
+			return;
+		}
+		if (!isVocabularyReady) {
+			return;
+		}
+		harvester.harvestInlineCodeFromDoc(doc);
+		harvester.logInlineCodeHarvest(trigger);
+	};
+
+	const ensureVocabularyReady = (): Promise<void> => {
+		if (isVocabularyReady) {
+			flushPendingSessionContext();
+			flushPendingHarvestTexts();
+			return Promise.resolve();
+		}
+		vocabularyLoadPromise ??= loadDefaultVocabulary({
+			isLocalLLM: options?.useLocalModel ?? false,
+			surface,
+		})
+			.then(() => {
+				if (destroyed) {
+					return;
+				}
+				isVocabularyReady = true;
+				flushPendingSessionContext();
+				flushPendingHarvestTexts();
+			})
+			.catch((error) => {
+				// Do not consume the pending text on failure. A later focus retries the
+				// load and can still apply the original context exactly once.
+				vocabularyLoadPromise = undefined;
+				logException(error as Error, {
+					location: 'editor-plugin-autocomplete/loadDefaultVocabulary',
+				});
+			});
+		return vocabularyLoadPromise;
+	};
 
 	const logContextResolved = (source: string, context?: AutocompleteContext): void => {
 		if (!isAutocompleteDebugEnabled()) {
@@ -679,6 +1018,7 @@ export const createAutocompletePlugin = (
 		// eslint-disable-next-line no-console
 		console.log('%c[CTC:signal]%c getContext resolved', CTC_STYLES.brand, CTC_STYLES.body, {
 			source,
+			scope: context?.contextScopeKey,
 			hasParentComment: !!context?.parentCommentContent,
 			parentCommentPreview: context?.parentCommentContent?.slice(0, 80),
 			siblingCount: context?.siblingCommentsContents?.length ?? 0,
@@ -686,7 +1026,109 @@ export const createAutocompletePlugin = (
 		});
 	};
 
+	const ingestContextText = (text?: string): void => {
+		if (!text) {
+			return;
+		}
+
+		if (!sessionIngestedContextTexts.has(text)) {
+			addBoundedContextText(pendingSessionContextTexts, text);
+		}
+		// Queued unconditionally rather than only once the chunk is present:
+		// context usually resolves in the same tick the load starts, and text
+		// dropped for arriving early is a reply that can never be harvested.
+		if (isInlineCodeHarvestEnabled && !harvestedContextTexts.has(text)) {
+			addBoundedContextText(pendingHarvestTexts, text);
+		}
+	};
+
+	const ingestResolvedContext = (): void => {
+		ingestContextText(resolvedContext?.fullPageContent);
+		ingestContextText(resolvedContext?.parentCommentContent);
+		for (const siblingCommentContent of resolvedContext?.siblingCommentsContents ?? []) {
+			ingestContextText(siblingCommentContent);
+		}
+		flushPendingSessionContext();
+		flushPendingHarvestTexts();
+	};
+
+	/**
+	 * Put back what this editor had contributed to the pot another editor just
+	 * emptied.
+	 *
+	 * The scope that ended belongs to the host that reported it, not to everyone
+	 * sharing these globals. Without this an editor alongside it — a comment box
+	 * under a chat panel that switched conversation — is left with none of its
+	 * learning and no way back to it: the dedupe sets below are per editor, so
+	 * its own page reads as already ingested and is skipped from then on.
+	 *
+	 * Nothing is re-fetched. The context this editor resolved is still held, and
+	 * what it describes has not changed just because another host moved on.
+	 *
+	 * Only for an editor that reported no scope. One that did is party to the
+	 * same scope system and the scope just dropped may well be its own: a
+	 * Confluence page transition mounts the incoming editor before tearing down
+	 * the outgoing one, and the outgoing one is still holding the page that was
+	 * left. Putting that back is exactly what the eviction was for.
+	 */
+	const reprimeSessionLearning = (): void => {
+		if (destroyed || resolvedContext?.contextScopeKey !== undefined) {
+			return;
+		}
+		pendingSessionContextTexts.clear();
+		sessionIngestedContextTexts.clear();
+		pendingHarvestTexts.clear();
+		harvestedContextTexts.clear();
+		ingestResolvedContext();
+		if (currentView) {
+			harvestDocument(currentView.state.doc, 'reprime');
+		}
+	};
+
+	/**
+	 * Drop everything learned for the scope that just ended.
+	 *
+	 * Both stores are claims about what is being discussed, and neither survives
+	 * the discussion changing: L1 boosts would keep a page's words ranked above
+	 * the next page's, and the harvested set holds one conversation's content.
+	 * The dedupe sets go too, so the context that arrives next is treated as
+	 * unseen and re-primes both — which is what makes this safe to do on a page
+	 * change, since the transcript is re-ingested along with the new page.
+	 *
+	 * The stores are shared, so every other mounted editor is put back in the
+	 * same tick from context it already holds. Only the scope that ended is
+	 * actually dropped.
+	 */
+	const resetSessionScopedLearning = (reason: string): void => {
+		resetSessionBoosts();
+		loadedInlineCodeHarvester?.resetInlineCodeHarvest();
+		resolvedContext = undefined;
+		pendingSessionContextTexts.clear();
+		sessionIngestedContextTexts.clear();
+		pendingHarvestTexts.clear();
+		harvestedContextTexts.clear();
+		ctcTag('init', `session-scoped learning reset · ${reason}`, CTC_STYLES.dim);
+		for (const reprimeOther of mountedEditors) {
+			if (reprimeOther !== reprimeSessionLearning) {
+				reprimeOther();
+			}
+		}
+	};
+
 	const applyContext = (context: AutocompleteContext): void => {
+		// A host that scopes its context tells us which scope each read belongs to.
+		// A read with no recorded key to compare against only records: that is the
+		// first since the last editor went away, so there is nothing left to throw
+		// away and resetting would drop the priming focus just started. A read from
+		// a newly mounted editor is not that case — the key outlives the editor
+		// precisely so a host that remounts across a navigation still evicts.
+		if (context.contextScopeKey !== undefined && context.contextScopeKey !== contextScopeKey) {
+			if (contextScopeKey !== undefined) {
+				resetSessionScopedLearning(`scope ${contextScopeKey} → ${context.contextScopeKey}`);
+			}
+			contextScopeKey = context.contextScopeKey;
+		}
+
 		// Merge rather than replace: the word-boundary retry may resolve only a
 		// late-arriving field (e.g. parentCommentContent) without re-sending
 		// fullPageContent, so replacing would drop previously resolved context.
@@ -697,28 +1139,7 @@ export const createAutocompletePlugin = (
 		);
 		resolvedContext = { ...resolvedContext, ...definedContext };
 
-		const ingestContextText = (text?: string): void => {
-			if (!text || ingestedContextTexts.has(text)) {
-				return;
-			}
-
-			ingestedContextTexts.add(text);
-			// Evict oldest entries (Set preserves insertion order) to bound memory.
-			while (ingestedContextTexts.size > MAX_INGESTED_CONTEXT_TEXTS) {
-				const oldest = ingestedContextTexts.values().next().value;
-				if (oldest === undefined) {
-					break;
-				}
-				ingestedContextTexts.delete(oldest);
-			}
-			ingestDocumentPage(text);
-		};
-
-		ingestContextText(context.fullPageContent);
-		ingestContextText(context.parentCommentContent);
-		for (const siblingCommentContent of context.siblingCommentsContents ?? []) {
-			ingestContextText(siblingCommentContent);
-		}
+		ingestResolvedContext();
 
 		// Context arrived after word boundaries may already have fired. Re-send
 		// slow-lane context immediately so the next inference includes the thread.
@@ -741,7 +1162,20 @@ export const createAutocompletePlugin = (
 		allowThrottle?: boolean;
 		source: string;
 	}): boolean => {
-		if (!options?.getContext || contextRequestInFlight) {
+		if (!options?.getContext) {
+			return false;
+		}
+
+		if (contextRequestInFlight) {
+			// Only the reads that bypass the throttle are worth keeping: those are
+			// the ones the host asked for by name, and a scope change travels among
+			// them with no second channel to arrive on, so losing one would strand
+			// the eviction until something else happened to move. A word-boundary
+			// poll is a retry loop for context that has not landed yet, and the read
+			// already open will bring it.
+			if (!allowThrottle) {
+				queuedContextRefreshSource = source;
+			}
 			return false;
 		}
 
@@ -776,6 +1210,11 @@ export const createAutocompletePlugin = (
 			})
 			.finally(() => {
 				contextRequestInFlight = false;
+				const queuedSource = queuedContextRefreshSource;
+				queuedContextRefreshSource = undefined;
+				if (queuedSource !== undefined && !destroyed) {
+					refreshContext({ source: queuedSource, allowThrottle: false });
+				}
 			});
 
 		return true;
@@ -817,6 +1256,63 @@ export const createAutocompletePlugin = (
 		cancelActiveDecision();
 	};
 
+	/**
+	 * Offer a harvested inline-code surface on a prefix the scored path left
+	 * empty. Returns whether one was committed.
+	 */
+	const commitHarvestedSuggestion = (view: EditorView, decision: PredictionDecision): boolean => {
+		const harvester = inlineCodeHarvester;
+		if (!harvester || !isInlineCodeHarvestEnabled) {
+			return false;
+		}
+		if (!scoredPathFinishedEmpty(decision.textBefore)) {
+			return false;
+		}
+
+		const typedPrefix = getTrailingSurfaceToken(decision.textBefore);
+		const match = harvester.findHarvestedCompletion(typedPrefix);
+		if (!match) {
+			return false;
+		}
+		if (
+			isSurfaceInAcceptCooldown(match.surface) ||
+			repeatsPrecedingText(match, decision.textBefore)
+		) {
+			return false;
+		}
+
+		const suggestion = showGhostText(
+			view,
+			buildHarvestPrediction(match),
+			decision.position,
+			decision.revision,
+			decision.startedAt,
+			match.typedPrefixLength,
+		);
+		if (!suggestion) {
+			return false;
+		}
+
+		cancelActiveDecision();
+		ctcTag(
+			'harvest',
+			`offered "${match.surface}" for "${typedPrefix}" · ${match.collapsedBy} · ${match.replyOccurrences} reply / ${match.documentSpans} doc sightings${
+				match.rivalSurfaces.length > 0 ? ` · over ${match.rivalSurfaces.join(', ')}` : ''
+			}`,
+			CTC_STYLES.lm,
+		);
+		if (suggestion.ghostText !== lastShownGhostText) {
+			lastShownGhostText = suggestion.ghostText;
+			api?.analytics?.actions.fireAnalyticsEvent({
+				action: ACTION.SUGGESTION_VIEWED,
+				actionSubject: ACTION_SUBJECT.CONTEXTUAL_TYPEAHEAD,
+				eventType: EVENT_TYPE.TRACK,
+				attributes: { completionSource: completionSourceFor(suggestion), surface },
+			});
+		}
+		return true;
+	};
+
 	const evaluateActiveDecision = (view: EditorView, revision: number): void => {
 		const decision = activeDecision;
 		if (!decision || decision.revision !== revision || !isDecisionCurrent(view, decision)) {
@@ -859,8 +1355,11 @@ export const createAutocompletePlugin = (
 
 			const prediction = predict(decision.textBefore);
 			if (!prediction || prediction.text.length === 0) {
-				// Remain in `collecting` until an async signal arrives or the hard
-				// deadline expires. We never display a provisional fallback.
+				// Only where the scored path has finished and come away with nothing
+				// does a harvested surface get to answer; otherwise remain in
+				// `collecting` until an async signal arrives or the hard deadline
+				// expires. We never display a provisional fallback.
+				commitHarvestedSuggestion(view, decision);
 				return;
 			}
 
@@ -924,7 +1423,7 @@ export const createAutocompletePlugin = (
 					action: ACTION.SUGGESTION_VIEWED,
 					actionSubject: ACTION_SUBJECT.CONTEXTUAL_TYPEAHEAD,
 					eventType: EVENT_TYPE.TRACK,
-					attributes: { completionSource: getCompletionSource(), surface },
+					attributes: { completionSource: completionSourceFor(suggestion), surface },
 				});
 			}
 		} catch (error) {
@@ -1136,11 +1635,14 @@ export const createAutocompletePlugin = (
 					});
 				},
 				Escape: (state: EditorState, dispatch?: (tr: Transaction) => void) => {
+					const dismissed = (
+						autocompletePluginKey.getState(state) as AutocompletePluginState | undefined
+					)?.suggestion;
 					const didClear = clearGhostText(state, dispatch);
 					if (didClear) {
 						cancelActiveDecision();
 						dismissedContext = getTextBeforeCursor(state);
-						fireSuggestionDismissedAnalytics('escape');
+						fireSuggestionDismissedAnalytics('escape', dismissed ?? null);
 					}
 					return didClear;
 				},
@@ -1158,7 +1660,7 @@ export const createAutocompletePlugin = (
 					if (pluginState?.ghostText) {
 						clearGhostText(view.state, view.dispatch);
 						cancelActiveDecision();
-						fireSuggestionDismissedAnalytics('blur');
+						fireSuggestionDismissedAnalytics('blur', pluginState.suggestion);
 					}
 					return false;
 				},
@@ -1168,12 +1670,15 @@ export const createAutocompletePlugin = (
 					}
 
 					if (!event.target.closest('[data-autocomplete-ghost="true"]')) {
+						const dismissed = (
+							autocompletePluginKey.getState(view.state) as AutocompletePluginState | undefined
+						)?.suggestion;
 						const didClear = clearGhostText(view.state, view.dispatch);
 						if (didClear) {
 							cancelActiveDecision();
 							dismissedContext = getTextBeforeCursor(view.state);
 							lastShownGhostText = '';
-							fireSuggestionDismissedAnalytics('click');
+							fireSuggestionDismissedAnalytics('click', dismissed ?? null);
 						}
 						return false;
 					}
@@ -1193,19 +1698,21 @@ export const createAutocompletePlugin = (
 
 					return accepted;
 				},
-				focus: () => {
+				focus: (view: EditorView) => {
 					if (!isAutocompleteEnabled) {
 						return false;
 					}
 
-					loadDefaultVocabulary({
-						isLocalLLM: options?.useLocalModel ?? false,
-						surface,
-					}).catch((error) => {
-						logException(error as Error, {
-							location: 'editor-plugin-autocomplete/loadDefaultVocabulary',
+					void ensureVocabularyReady();
+					// First point at which the session is known to be using the input,
+					// which is where the rest of the artifacts are requested too.
+					void ensureInlineCodeHarvester()
+						.then(() => harvestDocument(view.state.doc, 'focus'))
+						.catch((error) => {
+							logException(error as Error, {
+								location: 'editor-plugin-autocomplete/harvestDocument',
+							});
 						});
-					});
 					loadVectorsAsync({
 						isLocalLLM: options?.useLocalModel ?? false,
 						surface,
@@ -1238,11 +1745,13 @@ export const createAutocompletePlugin = (
 			// Capture up front so a subscription notification before the first PM
 			// transaction can still drive slowLaneClient.updateContext (gated on currentView).
 			currentView = editorView;
+			mountedEditors.add(reprimeSessionLearning);
 
 			// Push channel for hosts that keep producing context after mount (e.g. Rovo chat).
 			if (isAutocompleteEnabled && options?.subscribeToContextUpdates) {
 				unsubscribeFromContextUpdates = options.subscribeToContextUpdates(() => {
-					// Bypass throttle for freshness; the in-flight guard prevents overlap.
+					// Bypass throttle for freshness; a read still open defers this one
+					// rather than overlapping it.
 					refreshContext({ source: 'subscription', allowThrottle: false });
 				});
 			}
@@ -1274,6 +1783,11 @@ export const createAutocompletePlugin = (
 								buildSlowLaneText(view.state.doc.textContent, resolvedContext),
 							);
 
+							// The backtick input rule has fired by the time a span is
+							// finished, so a word boundary is the earliest point the mark
+							// exists to be found.
+							harvestDocument(view.state.doc, 'word-boundary');
+
 							// Context may not have resolved on first focus (e.g. comment
 							// thread still loading). Retry on word boundaries until we have
 							// the parent comment, throttled so we don't refetch constantly
@@ -1313,7 +1827,34 @@ export const createAutocompletePlugin = (
 					if (hasDestroy(slowLaneClient)) {
 						slowLaneClient.destroy();
 					}
-					ingestedContextTexts.clear();
+					queuedContextRefreshSource = undefined;
+					pendingSessionContextTexts.clear();
+					sessionIngestedContextTexts.clear();
+					pendingHarvestTexts.clear();
+					harvestedContextTexts.clear();
+					// The harvested set holds one conversation's user and assistant
+					// content, and the L1 boosts describe what that conversation was
+					// about. Both live at module scope, so they have to be emptied here
+					// or they leak into whichever editor mounts next — but only once no
+					// editor is left to be using them. The scope key goes with them, and
+					// only with them: clearing it while another editor is still mounted
+					// would leave that editor's next read looking like a first one, with
+					// nothing to compare against and everything still loaded.
+					mountedEditors.delete(reprimeSessionLearning);
+					if (mountedEditors.size === 0) {
+						loadedInlineCodeHarvester?.resetInlineCodeHarvest();
+						// Only for a host that scopes its context, which is the one asking
+						// for its learning to end with the conversation. A host that sends
+						// no scope has boosts belonging to the page it is on, and that page
+						// outlives an editor being unmounted — a Confluence comment box is
+						// closed far more often than the page under it changes.
+						if (contextScopeKey !== undefined) {
+							resetSessionBoosts();
+							contextScopeKey = undefined;
+						}
+					}
+					inlineCodeHarvester = null;
+					inlineCodeHarvesterPromise = undefined;
 				},
 			};
 		},