@atlaskit/editor-plugin-autocomplete 9.0.0 → 9.2.0

package/dist/es2019/pm-plugins/autocomplete-plugin.js

@@ -6,10 +6,13 @@ import { PluginKey } from '@atlaskit/editor-prosemirror/state';
 import { DecorationSet } from '@atlaskit/editor-prosemirror/view';
 import { CTC_STYLES, ctcTag, isAutocompleteDebugEnabled, 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 { createLocalSlowLaneClient } from './local-slow-lane-client';
 import { loadGrammarDataAsync } from './scoring-pipeline';
 import { clearDefaultSlowLaneClient, createSlowLaneClient, getDefaultSlowLaneClientStatus, isWordBoundary, setDefaultSlowLaneClient } from './slow-lane-client';
-import { predict, loadDefaultVocabulary, loadVectorsAsync, incrementSessionFreq, ingestDocumentPage, getLastPredictionDebug, noteSuggestionAccepted } from './text-predictor';
+import { predict, loadDefaultVocabulary, loadVectorsAsync, incrementSessionFreq, ingestDocumentPage, getLastPredictionDebug, getLastPredictionOutcome, isSurfaceInAcceptCooldown, noteSuggestionAccepted, resetSessionBoosts } from './text-predictor';
 export const autocompletePluginKey = new PluginKey('autocomplete');
 const PREDICTION_COALESCE_MS = 0;
 const GHOST_DECISION_BUDGET_MS = 100;
@@ -20,6 +23,32 @@ 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();
+// 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;
+// 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 = 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
@@ -94,11 +123,16 @@ const advanceGhostThroughTypedCharacter = (tr, pluginState) => {
     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.
+    // 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
+      position: nextPosition,
+      ...(suggestion.replacesTypedPrefixLength === undefined ? {} : {
+        replacesTypedPrefixLength: suggestion.replacesTypedPrefixLength + 1
+      })
     }
   };
 };
@@ -135,10 +169,11 @@ const getTextBeforeCursor = state => {
   }
   return fullText.slice(-maxChars);
 };
-const getTrailingSurfacePrefixLength = text => {
+const getTrailingSurfaceToken = text => {
   var _text$trimEnd$match$, _text$trimEnd$match;
-  return (_text$trimEnd$match$ = (_text$trimEnd$match = text.trimEnd().match(TRAILING_SURFACE_PREFIX_REGEX)) === null || _text$trimEnd$match === void 0 ? void 0 : _text$trimEnd$match[0].length) !== null && _text$trimEnd$match$ !== void 0 ? _text$trimEnd$match$ : 0;
+  return (_text$trimEnd$match$ = (_text$trimEnd$match = text.trimEnd().match(TRAILING_SURFACE_PREFIX_REGEX)) === null || _text$trimEnd$match === void 0 ? void 0 : _text$trimEnd$match[0]) !== null && _text$trimEnd$match$ !== void 0 ? _text$trimEnd$match$ : '';
 };
+const getTrailingSurfacePrefixLength = text => getTrailingSurfaceToken(text).length;
 
 /**
  * Set the autocomplete state via a transaction metadata.
@@ -151,13 +186,16 @@ const setAutocompleteMeta = (tr, meta) => {
  * Apply a ghost text suggestion to the editor state.
  */
 let lastShownGhostText = '';
-const showGhostText = (view, prediction, position, revision, decisionStartedAt) => {
+const showGhostText = (view, prediction, position, revision, decisionStartedAt, replacesTypedPrefixLength) => {
   try {
     const {
       state,
       dispatch
     } = view;
     const suggestion = {
+      ...(replacesTypedPrefixLength === undefined ? {} : {
+        replacesTypedPrefixLength
+      }),
       decisionLatencyMs: performance.now() - decisionStartedAt,
       evidenceTier: prediction.evidenceTier,
       ghostText: prediction.text,
@@ -226,12 +264,33 @@ const acceptGhostText = (state, dispatch) => {
   }
   if (dispatch) {
     try {
+      var _suggestion$replacesT;
       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$replacesT = suggestion.replacesTypedPrefixLength) !== null && _suggestion$replacesT !== void 0 ? _suggestion$replacesT : 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,
@@ -319,6 +378,69 @@ const getLeadingTextCharacter = text => {
   }
   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 = '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 => {
+  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, textBefore) => {
+  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 => ({
+  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 => {
   if (!locale) {
     return false;
@@ -330,6 +452,7 @@ export const createAutocompletePlugin = (options, api) => {
   const surface = (_options$surface = options === null || options === void 0 ? void 0 : options.surface) !== null && _options$surface !== void 0 ? _options$surface : 'editor';
   const locale = (_options$locale = options === null || options === void 0 ? void 0 : options.locale) !== null && _options$locale !== void 0 ? _options$locale : typeof navigator !== 'undefined' ? navigator.language : undefined;
   const isAutocompleteEnabled = isEnglishLocale(locale);
+  const isInlineCodeHarvestEnabled = isAutocompleteEnabled && (options === null || options === void 0 ? void 0 : options.harvestInlineCode) === true;
   let debounceTimer = null;
   let decisionDeadlineTimer = null;
   let hasIngestedPage = false;
@@ -372,14 +495,24 @@ export const createAutocompletePlugin = (options, api) => {
     }
     return options !== null && options !== void 0 && options.useLocalModel ? 'localLlm' : 'server';
   };
-  const fireSuggestionDismissedAnalytics = reason => {
+
+  /**
+   * 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 => (suggestion === null || suggestion === void 0 ? void 0 : suggestion.evidenceTier) === 'session-harvest' ? 'harvest' : getCompletionSource();
+  const fireSuggestionDismissedAnalytics = (reason, suggestion) => {
     var _api$analytics;
     api === null || api === void 0 ? void 0 : (_api$analytics = api.analytics) === null || _api$analytics === void 0 ? void 0 : _api$analytics.actions.fireAnalyticsEvent({
       action: ACTION.SUGGESTION_DISMISSED,
       actionSubject: ACTION_SUBJECT.CONTEXTUAL_TYPEAHEAD,
       eventType: EVENT_TYPE.TRACK,
       attributes: {
-        completionSource: getCompletionSource(),
+        completionSource: completionSourceFor(suggestion),
         reason,
         surface
       }
@@ -436,7 +569,7 @@ export const createAutocompletePlugin = (options, api) => {
       actionSubject: ACTION_SUBJECT.CONTEXTUAL_TYPEAHEAD,
       eventType: EVENT_TYPE.TRACK,
       attributes: {
-        completionSource: getCompletionSource(),
+        completionSource: completionSourceFor(suggestion),
         suggestionLength,
         typedLength,
         kssDelta,
@@ -504,6 +637,10 @@ export const createAutocompletePlugin = (options, api) => {
   const registeredSlowLaneStatus = getDefaultSlowLaneClientStatus();
   ctcTag('init', `slow lane registered · id=${slowLaneClientId} · selected=${slowLaneClientKind} · canonical=${registeredSlowLaneStatus.canonicalScoringSupported ? 'yes' : 'no'} · ready=${(_registeredSlowLaneSt = registeredSlowLaneStatus.localModelReady) !== null && _registeredSlowLaneSt !== void 0 ? _registeredSlowLaneSt : 'n/a'}`, slowLaneClientKind === 'localLlm' ? CTC_STYLES.good : CTC_STYLES.warn);
   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;
   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).
@@ -511,7 +648,145 @@ export const createAutocompletePlugin = (options, api) => {
   // 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();
+  // 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();
+  const sessionIngestedContextTexts = new Set();
+  let isVocabularyReady = false;
+  let vocabularyLoadPromise;
+
+  // 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();
+  // 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();
+  let inlineCodeHarvester = null;
+  let inlineCodeHarvesterPromise;
+  const addBoundedContextText = (texts, text) => {
+    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 = () => {
+    if (!isVocabularyReady || destroyed) {
+      return;
+    }
+    for (const text of pendingSessionContextTexts) {
+      if (!sessionIngestedContextTexts.has(text)) {
+        ingestDocumentPage(text);
+        addBoundedContextText(sessionIngestedContextTexts, text);
+      }
+      pendingSessionContextTexts.delete(text);
+    }
+  };
+  const flushPendingHarvestTexts = () => {
+    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 = () => {
+    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, {
+        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, trigger) => {
+    if (!isInlineCodeHarvestEnabled || destroyed) {
+      return;
+    }
+    const harvester = inlineCodeHarvester;
+    if (!harvester) {
+      void ensureInlineCodeHarvester();
+      return;
+    }
+    if (!isVocabularyReady) {
+      return;
+    }
+    harvester.harvestInlineCodeFromDoc(doc);
+    harvester.logInlineCodeHarvest(trigger);
+  };
+  const ensureVocabularyReady = () => {
+    var _options$useLocalMode;
+    if (isVocabularyReady) {
+      flushPendingSessionContext();
+      flushPendingHarvestTexts();
+      return Promise.resolve();
+    }
+    vocabularyLoadPromise ??= loadDefaultVocabulary({
+      isLocalLLM: (_options$useLocalMode = options === null || options === void 0 ? void 0 : options.useLocalModel) !== null && _options$useLocalMode !== void 0 ? _options$useLocalMode : 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, {
+        location: 'editor-plugin-autocomplete/loadDefaultVocabulary'
+      });
+    });
+    return vocabularyLoadPromise;
+  };
   const logContextResolved = (source, context) => {
     var _context$parentCommen, _context$siblingComme4, _context$siblingComme5;
     if (!isAutocompleteDebugEnabled()) {
@@ -521,13 +796,117 @@ export const createAutocompletePlugin = (options, api) => {
     // eslint-disable-next-line no-console
     console.log('%c[CTC:signal]%c getContext resolved', CTC_STYLES.brand, CTC_STYLES.body, {
       source,
+      scope: context === null || context === void 0 ? void 0 : context.contextScopeKey,
       hasParentComment: !!(context !== null && context !== void 0 && context.parentCommentContent),
       parentCommentPreview: context === null || context === void 0 ? void 0 : (_context$parentCommen = context.parentCommentContent) === null || _context$parentCommen === void 0 ? void 0 : _context$parentCommen.slice(0, 80),
       siblingCount: (_context$siblingComme4 = context === null || context === void 0 ? void 0 : (_context$siblingComme5 = context.siblingCommentsContents) === null || _context$siblingComme5 === void 0 ? void 0 : _context$siblingComme5.length) !== null && _context$siblingComme4 !== void 0 ? _context$siblingComme4 : 0,
       hasFullPage: !!(context !== null && context !== void 0 && context.fullPageContent)
     });
   };
+  const ingestContextText = text => {
+    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 = () => {
+    var _resolvedContext, _resolvedContext2;
+    ingestContextText((_resolvedContext = resolvedContext) === null || _resolvedContext === void 0 ? void 0 : _resolvedContext.fullPageContent);
+    ingestContextText((_resolvedContext2 = resolvedContext) === null || _resolvedContext2 === void 0 ? void 0 : _resolvedContext2.parentCommentContent);
+    for (const siblingCommentContent of (_resolvedContext$sibl = (_resolvedContext3 = resolvedContext) === null || _resolvedContext3 === void 0 ? void 0 : _resolvedContext3.siblingCommentsContents) !== null && _resolvedContext$sibl !== void 0 ? _resolvedContext$sibl : []) {
+      var _resolvedContext$sibl, _resolvedContext3;
+      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 = () => {
+    var _resolvedContext4;
+    if (destroyed || ((_resolvedContext4 = resolvedContext) === null || _resolvedContext4 === void 0 ? void 0 : _resolvedContext4.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 => {
+    var _loadedInlineCodeHarv;
+    resetSessionBoosts();
+    (_loadedInlineCodeHarv = loadedInlineCodeHarvester) === null || _loadedInlineCodeHarv === void 0 ? void 0 : _loadedInlineCodeHarv.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 => {
+    // 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.
@@ -538,27 +917,7 @@ export const createAutocompletePlugin = (options, api) => {
       ...resolvedContext,
       ...definedContext
     };
-    const ingestContextText = text => {
-      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$siblingComme6 = context.siblingCommentsContents) !== null && _context$siblingComme6 !== void 0 ? _context$siblingComme6 : []) {
-      var _context$siblingComme6;
-      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.
@@ -576,7 +935,19 @@ export const createAutocompletePlugin = (options, api) => {
     source,
     allowThrottle = true
   }) => {
-    if (!(options !== null && options !== void 0 && options.getContext) || contextRequestInFlight) {
+    if (!(options !== null && options !== void 0 && 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;
     }
     const now = Date.now();
@@ -603,6 +974,14 @@ export const createAutocompletePlugin = (options, api) => {
       });
     }).finally(() => {
       contextRequestInFlight = false;
+      const queuedSource = queuedContextRefreshSource;
+      queuedContextRefreshSource = undefined;
+      if (queuedSource !== undefined && !destroyed) {
+        refreshContext({
+          source: queuedSource,
+          allowThrottle: false
+        });
+      }
     });
     return true;
   };
@@ -637,6 +1016,48 @@ export const createAutocompletePlugin = (options, api) => {
     }
     cancelActiveDecision();
   };
+
+  /**
+   * Offer a harvested inline-code surface on a prefix the scored path left
+   * empty. Returns whether one was committed.
+   */
+  const commitHarvestedSuggestion = (view, decision) => {
+    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) {
+      var _api$analytics5;
+      lastShownGhostText = suggestion.ghostText;
+      api === null || api === void 0 ? void 0 : (_api$analytics5 = api.analytics) === null || _api$analytics5 === void 0 ? void 0 : _api$analytics5.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, revision) => {
     const decision = activeDecision;
     if (!decision || decision.revision !== revision || !isDecisionCurrent(view, decision)) {
@@ -677,8 +1098,11 @@ export const createAutocompletePlugin = (options, api) => {
       }
       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;
       }
       const readyAtMs = performance.now() - decision.startedAt;
@@ -718,14 +1142,14 @@ export const createAutocompletePlugin = (options, api) => {
         });
       }
       if (suggestion.ghostText !== lastShownGhostText) {
-        var _api$analytics5;
+        var _api$analytics6;
         lastShownGhostText = suggestion.ghostText;
-        api === null || api === void 0 ? void 0 : (_api$analytics5 = api.analytics) === null || _api$analytics5 === void 0 ? void 0 : _api$analytics5.actions.fireAnalyticsEvent({
+        api === null || api === void 0 ? void 0 : (_api$analytics6 = api.analytics) === null || _api$analytics6 === void 0 ? void 0 : _api$analytics6.actions.fireAnalyticsEvent({
           action: ACTION.SUGGESTION_VIEWED,
           actionSubject: ACTION_SUBJECT.CONTEXTUAL_TYPEAHEAD,
           eventType: EVENT_TYPE.TRACK,
           attributes: {
-            completionSource: getCompletionSource(),
+            completionSource: completionSourceFor(suggestion),
             surface
           }
         });
@@ -913,11 +1337,13 @@ export const createAutocompletePlugin = (options, api) => {
           });
         },
         Escape: (state, dispatch) => {
+          var _autocompletePluginKe;
+          const dismissed = (_autocompletePluginKe = autocompletePluginKey.getState(state)) === null || _autocompletePluginKe === void 0 ? void 0 : _autocompletePluginKe.suggestion;
           const didClear = clearGhostText(state, dispatch);
           if (didClear) {
             cancelActiveDecision();
             dismissedContext = getTextBeforeCursor(state);
-            fireSuggestionDismissedAnalytics('escape');
+            fireSuggestionDismissedAnalytics('escape', dismissed !== null && dismissed !== void 0 ? dismissed : null);
           }
           return didClear;
         }
@@ -931,7 +1357,7 @@ export const createAutocompletePlugin = (options, api) => {
           if (pluginState !== null && pluginState !== void 0 && pluginState.ghostText) {
             clearGhostText(view.state, view.dispatch);
             cancelActiveDecision();
-            fireSuggestionDismissedAnalytics('blur');
+            fireSuggestionDismissedAnalytics('blur', pluginState.suggestion);
           }
           return false;
         },
@@ -940,12 +1366,14 @@ export const createAutocompletePlugin = (options, api) => {
             return false;
           }
           if (!event.target.closest('[data-autocomplete-ghost="true"]')) {
+            var _autocompletePluginKe2;
+            const dismissed = (_autocompletePluginKe2 = autocompletePluginKey.getState(view.state)) === null || _autocompletePluginKe2 === void 0 ? void 0 : _autocompletePluginKe2.suggestion;
             const didClear = clearGhostText(view.state, view.dispatch);
             if (didClear) {
               cancelActiveDecision();
               dismissedContext = getTextBeforeCursor(view.state);
               lastShownGhostText = '';
-              fireSuggestionDismissedAnalytics('click');
+              fireSuggestionDismissedAnalytics('click', dismissed !== null && dismissed !== void 0 ? dismissed : null);
             }
             return false;
           }
@@ -961,17 +1389,17 @@ export const createAutocompletePlugin = (options, api) => {
           }
           return accepted;
         },
-        focus: () => {
-          var _options$useLocalMode, _options$useLocalMode2, _options$useLocalMode3;
+        focus: view => {
+          var _options$useLocalMode2, _options$useLocalMode3;
           if (!isAutocompleteEnabled) {
             return false;
           }
-          loadDefaultVocabulary({
-            isLocalLLM: (_options$useLocalMode = options === null || options === void 0 ? void 0 : options.useLocalModel) !== null && _options$useLocalMode !== void 0 ? _options$useLocalMode : false,
-            surface
-          }).catch(error => {
+          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, {
-              location: 'editor-plugin-autocomplete/loadDefaultVocabulary'
+              location: 'editor-plugin-autocomplete/harvestDocument'
             });
           });
           loadVectorsAsync({
@@ -1005,11 +1433,13 @@ export const createAutocompletePlugin = (options, api) => {
       // 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 !== null && options !== void 0 && 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
@@ -1035,16 +1465,21 @@ export const createAutocompletePlugin = (options, api) => {
             maybeUpdateSessionFrequency(view, prevState);
             const textBefore = getTextBeforeCursor(view.state);
             if (isWordBoundary(textBefore)) {
-              var _resolvedContext;
+              var _resolvedContext5;
               slowLaneClient.updateContext(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
               // and capped so non-comment editors stop retrying entirely.
               // Skipped for push-channel hosts (subscribeToContextUpdates): they
               // never grow parentCommentContent, so polling only burns the budget.
-              if (!(options !== null && options !== void 0 && options.subscribeToContextUpdates) && !((_resolvedContext = resolvedContext) !== null && _resolvedContext !== void 0 && _resolvedContext.parentCommentContent) && wordBoundaryRefreshAttempts < MAX_CONTEXT_REFRESH_ATTEMPTS) {
+              if (!(options !== null && options !== void 0 && options.subscribeToContextUpdates) && !((_resolvedContext5 = resolvedContext) !== null && _resolvedContext5 !== void 0 && _resolvedContext5.parentCommentContent) && wordBoundaryRefreshAttempts < MAX_CONTEXT_REFRESH_ATTEMPTS) {
                 // Only count the attempt when a fetch actually started, so an
                 // in-flight or throttled no-op doesn't burn the retry budget.
                 if (refreshContext({
@@ -1071,7 +1506,35 @@ export const createAutocompletePlugin = (options, api) => {
           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) {
+            var _loadedInlineCodeHarv2;
+            (_loadedInlineCodeHarv2 = loadedInlineCodeHarvester) === null || _loadedInlineCodeHarv2 === void 0 ? void 0 : _loadedInlineCodeHarv2.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;
         }
       };
     }