@atlaskit/editor-plugin-autocomplete 8.0.0 → 9.0.0

package/dist/esm/pm-plugins/local-slow-lane-client.js

@@ -1,14 +1,13 @@
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
-import _createClass from "@babel/runtime/helpers/createClass";
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import _typeof from "@babel/runtime/helpers/typeof";
 function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
 function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
 function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 import _regeneratorRuntime from "@babel/runtime/regenerator";
 /**
  * Local Slow Lane Client: On-device inference via @mlc-ai/web-llm.
@@ -17,11 +16,9 @@ import _regeneratorRuntime from "@babel/runtime/regenerator";
  * a backend API, this client runs two models in the browser via WebGPU, in a
  * single MLCEngine, to reproduce the BE encoder's outputs on-device:
  *
- *   - Causal LM (SmolLM2-135M-Instruct): one decode step per word boundary. A
- *     registered LogitProcessor captures the raw next-token logits, which
- *     `computeBePayload` turns into a whole-word `lm_logits` payload — a faithful
- *     port of the BE `CausalLMEncoder._get_top_k_probs` (masked softmax over the
- *     vocab's first-tokens, prefix expansion, L2 reservation, log-space pooling).
+ *   - Causal LM (SmolLM2-135M-Instruct): context-keyed one-step boundary primes
+ *     provide canonical first-token logits. A persistent token-prefix scheduler
+ *     expands shared paths and exact-scores only plausible finalists.
  *   - Semantic embedder (Snowflake Arctic Embed S): produces the real 384-d
  *     `semantic_vector`. Inputs are wrapped as passages (see `wrapForArctic`) so
  *     the runtime vector lands in the same space as the precomputed word bin.
@@ -31,7 +28,7 @@ import _regeneratorRuntime from "@babel/runtime/regenerator";
  * the main thread is viable:
  *
  *   - WebGPU GPU compute is inherently async (doesn't block the main thread)
- *   - CPU overhead (BE-parity post-processing) is a few ms
+ *   - CPU overhead for named-token reads and cache bookkeeping is small
  *   - Per-inference latency is well within autocomplete expectations
  *     (~250 ms between word boundaries)
  *
@@ -42,16 +39,21 @@ import _regeneratorRuntime from "@babel/runtime/regenerator";
  *   - Standard npm import — just works
  *
  * ── Interface ────────────────────────────────────────────────────────────
- * Same shape as createSlowLaneClient so text-predictor.ts needs zero changes.
- * The client exposes getContextVector() and getLmLogits() which are populated
- * asynchronously after each updateContext() call.
+ * Same base shape as createSlowLaneClient, plus on-device canonical-surface
+ * scoring. Semantic updates remain word-boundary timed; causal work is requested
+ * independently for exact pre-surface contexts.
  */
 
 import { abortExp, EXPERIENCE_NAME, failExp, startExp, succeedExp } from '../analytics/ufo';
-import { ARTIFACT_NAME, fetchArtifactJson } from './artifacts-manifest';
-import { isAutocompleteDebugEnabled } from './debug-mode';
+import { fetchAutocompleteArtifactJson } from './artifact-loader';
+import { ARTIFACT_NAME } from './artifacts-manifest';
+import { CanonicalLogitProcessor, CanonicalSurfaceTokenTrie, logSoftmaxAt, logSumExp } from './canonical-lm-scoring';
+import { CTC_STYLES, isAutocompleteDebugEnabled, isAutocompleteDebugVerbose } from './debug-mode';
+import { MIN_WINNER_MARGIN, STAGE1_WEIGHT, STAGE2_WEIGHT } from './scoring-pipeline';
 import { isWordBoundary } from './slow-lane-client';
 
+/** Which of the two causal-LM call shapes a measurement or log line describes. */
+
 // ─── Types ───────────────────────────────────────────────────────────────────
 
 // Same return type as createSlowLaneClient for drop-in compatibility
@@ -103,22 +105,7 @@ export var LOCAL_MLC_EMBEDDING_MODEL_ID = 'snowflake-arctic-embed-s-q0f32-MLC-b4
 export var wrapForArctic = function wrapForArctic(text) {
   return "[CLS] ".concat(text, " [SEP]");
 };
-
-/**
- * BE-parity constants — must match `CausalLMEncoder` defaults in the Python
- * sidecar (`cc-smarts/python-sidecar/src/causal_lm_encoder.py`) and
- * `SlowLaneEngine` (`typeahead_context_encoding.py`) so local payloads behave
- * identically to the server-client setup.
- */
-export var BE_PARITY = {
-  /** Final payload size cap (BE: `top_k_words`). */
-  TOP_K_WORDS: 2000,
-  /** L2 (domain) words admitted unconditionally before pooling (BE: `reserved_l2_slots`). */
-  RESERVED_L2_SLOTS: 500,
-  /** Log-space additive bias favouring L2 over L3 in the pool (BE: `l2_bias`). */
-  L2_BIAS: 1.0,
-  /** Drop words below this probability from the final payload (BE: `> 0.00001`). */
-  MIN_PROB: 0.00001,
+export var LOCAL_INFERENCE = {
   /**
    * Word-level approximation of the BE causal LM token limit.
    *
@@ -139,6 +126,72 @@ export var BE_PARITY = {
    */
   MAX_CONTEXT_WORDS: 100
 };
+export var CANONICAL_SCORING = {
+  /**
+   * How many contexts keep their prefilled state before the oldest is dropped.
+   *
+   * Sizes every context-keyed cache together on purpose: an expansion needs
+   * both the boundary logits and the candidate list to still be resident, so
+   * bounding them separately would evict half of a context and strand the
+   * other half.
+   *
+   * The context of a keystroke is the text *before* the word being typed,
+   * which does not change while that word is typed, so one word should cost
+   * one prefill and then hit. Measured hit rate was 45% over the first 84s of
+   * a session and 24% over the following four minutes, well short of that, and
+   * prompt prefills per decision rose 0.80 → 1.25 across the same split while
+   * cost per prefill stayed flat. Contexts were being dropped while still live.
+   *
+   * A boundary entry holds a `Float32Array` over the 49,152-token vocabulary,
+   * so each one is ~192KB and this bound is the dominant term in the scorer's
+   * footprint: ~24MB resident here, against ~6MB at the 32 this replaced. That
+   * cost is what kept the bound low, not a hit rate anyone had measured.
+   */
+  BOUNDARY_CACHE_MAX: 128,
+  EXACT_MAX_TARGET_TOKENS: 8,
+  PREFIX_CACHE_MAX: 256,
+  /**
+   * How many candidates compete for expansion in one context.
+   *
+   * Each distinct token prefix among them is a separate branch, and a branch
+   * the engine is not already standing on costs a prompt prefill before its
+   * first decode. A wide field therefore spreads a decision's round trips
+   * across candidates and finishes none of them inside the budget.
+   */
+  PROGRESSIVE_CANDIDATES_MAX: 8,
+  /**
+   * Ceiling on distinct token prefixes explored per context.
+   *
+   * Raising this to 8 to give long surfaces more room did the opposite: model
+   * calls per decision went 2.35 → 4.32, the warm-KV extend share fell 40% →
+   * 31% as the extra branches displaced the live path, the prefix queue backed
+   * up to 29 deep, and acceptances per thousand decisions fell 9.3 → 6.7. No
+   * phrase was shown either way, so breadth was never the binding constraint.
+   *
+   * What blocked them then was normalisation against a short word's per-token
+   * mean, which has since been replaced by a posterior over sequence
+   * log-likelihoods. That removes the bias towards short surfaces but does not
+   * by itself make phrases reachable: a longer surface is strictly less likely
+   * than a shorter one, so a phrase sharing a shortlist with a unigram still
+   * holds little of its mass. Whether the remaining gap is the threshold or the
+   * comparison is still open.
+   */
+  PROGRESSIVE_EXPANSIONS_PER_CONTEXT_MAX: 4,
+  PROGRESSIVE_INPUT_MAX: 400,
+  SURFACE_CACHE_MAX: 128,
+  TIER_A_PRIMES_MAX: 3
+};
+/**
+ * How much optimistic score we give up to stay on the warm KV path.
+ *
+ * Expanding a prefix the cache already holds costs one decode step, while
+ * branching to any other prefix costs a full prompt prefill first. Measured,
+ * that is about 30ms against about 66ms, so continuing the live path is worth
+ * roughly half a round trip and the margin has to be wide enough to reflect
+ * that. At the previous 0.05 almost any ranking difference was enough to
+ * abandon the sequence, and 70% of expansions ended up re-prefilling.
+ */
+var PROGRESSIVE_WARM_PATH_MARGIN = 0.25;
 var splitOnWhitespace = function splitOnWhitespace(text) {
   var trimmed = text.trim();
   if (trimmed === '') {
@@ -173,114 +226,60 @@ var truncateToLastNWords = function truncateToLastNWords(text, n) {
   return words.length <= n ? text : words.slice(-n).join(' ');
 };
 
-// ─── Logit capture ─────────────────────────────────────────────────────────
-
-/**
- * A LogitProcessor that captures the raw next-token logits and passes them
- * through unmodified.
- *
- * web-llm invokes `processLogits` on the CPU after the model's forward pass and
- * before sampling, handing us the full `Float32Array(vocab_size)` at the current
- * decode position. We copy it off web-llm's shared buffer (which it may reuse
- * across calls) and return the original untouched so sampling is unaffected.
- *
- * This is the raw-logit access the BE-parity algorithm needs (masked softmax +
- * prefix expansion, consumed in a later step). Registered for the causal LM
- * only — the embedder never decodes tokens, so it produces no logits.
- */
-var CapturingLogitProcessor = /*#__PURE__*/_createClass(function CapturingLogitProcessor() {
-  var _this = this;
-  _classCallCheck(this, CapturingLogitProcessor);
-  _defineProperty(this, "captured", null);
-  _defineProperty(this, "processLogits", function (logits) {
-    // Copy off web-llm's shared buffer — it may reuse `logits` across calls.
-    _this.captured = new Float32Array(logits);
-    return logits;
-  });
-  _defineProperty(this, "processSampledToken", function () {
-    // No-op — we don't track sampled tokens.
-  });
-  _defineProperty(this, "resetState", function () {
-    _this.captured = null;
-  });
-}); // ─── BE-parity data + algorithm ──────────────────────────────────────────────
 /**
- * Prefix-expansion map: first-token id → words whose space-prefixed SmolLM2
- * encoding starts with that token. Generated offline by
- * `scripts/gen_first_token_to_words.py`, which mirrors the BE's in-memory map
- * (`CausalLMEncoder._ensure_loaded`).
- *
- * Populated lazily by `loadBePayloadData()` from a dynamically-imported JSON so
- * the (large) payload is only fetched when the local client is actually
- * initialised — keeping it out of the editor's main chunk for the vast majority
- * of users (who run with `useLocalModel` off).
+ * Full canonical leading-space token sequence for every served surface. The
+ * producer keeps the existing `phrase-continuation-tokens.json` wire name while
+ * expanding its key set to the complete word/bigram/phrase union.
  */
-var firstTokenToWords = new Map();
-
-/**
- * L2 (Atlassian-domain) word set, derived from the keys of `vocabulary_10k.json`.
- * Used by `computeBePayload` for tier-aware ranking: any word in the prefix map
- * that is not in this set is treated as L3 (general English), matching the BE.
- * Populated lazily alongside `firstTokenToWords` — see `loadBePayloadData()`.
- */
-var l2Words = new Set();
-
-/**
- * Array of token IDs that appear as a first token for at least one vocabulary
- * word. Derived from `firstTokenToWords` when the data loads so `computeBePayload`
- * does not re-allocate this array on every word-boundary call.
- */
-var prefixMapTokenIds = [];
+var surfaceTokenIds = new Map();
+var surfaceTokenTrie = new CanonicalSurfaceTokenTrie();
 
 /** De-dupes concurrent loads and lets repeated calls await the same payload. */
-var bePayloadDataPromise;
+var surfaceTokenIdsPromise;
+var isPhraseContinuationTokens = function isPhraseContinuationTokens(payload) {
+  if (payload == null || _typeof(payload) !== 'object') {
+    return false;
+  }
+  return Object.values(payload).every(function (value) {
+    return Array.isArray(value) && value.every(function (entry) {
+      return typeof entry === 'number' && entry >= 0;
+    });
+  });
+};
 
-/**
- * Lazily load and build the BE-parity lookup tables from their CDN payloads.
- * Both artifacts are fetched on demand so neither is downloaded unless local
- * inference is initialised.
- *
- * :returns:
- *   A promise that resolves once `firstTokenToWords`, `l2Words` and
- *   `prefixMapTokenIds` are populated.
- */
-var loadBePayloadData = function loadBePayloadData() {
-  if (!bePayloadDataPromise) {
-    bePayloadDataPromise = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-      var _yield$Promise$all, _yield$Promise$all2, firstTokenToWordsData, vocabularyData;
+/** Lazily load the producer's full-union canonical surface token map. */
+var loadCanonicalSurfaceTokens = function loadCanonicalSurfaceTokens() {
+  if (!surfaceTokenIdsPromise) {
+    surfaceTokenIdsPromise = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      var continuationTokensData;
       return _regeneratorRuntime.wrap(function (_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
             _context.next = 1;
-            return Promise.all([fetchArtifactJson(ARTIFACT_NAME.FIRST_TOKEN_TO_WORDS), fetchArtifactJson(ARTIFACT_NAME.VOCABULARY)]);
+            return fetchAutocompleteArtifactJson(ARTIFACT_NAME.PHRASE_CONTINUATION_TOKENS, {
+              summarize: function summarize(payload) {
+                return "".concat(Object.keys(payload).length, " surfaces");
+              },
+              validate: isPhraseContinuationTokens
+            }).catch(function () {
+              return null;
+            });
           case 1:
-            _yield$Promise$all = _context.sent;
-            _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 2);
-            firstTokenToWordsData = _yield$Promise$all2[0];
-            vocabularyData = _yield$Promise$all2[1];
-            if (!(firstTokenToWordsData == null || (vocabularyData === null || vocabularyData === void 0 ? void 0 : vocabularyData.words) == null)) {
-              _context.next = 2;
-              break;
-            }
-            throw new Error("[LocalSlowLane] unexpected artifact payload \u2014 " + "firstTokenToWordsData=".concat(firstTokenToWordsData == null ? 'null/undefined' : 'defined', ", ") + "vocabularyData=".concat(vocabularyData == null ? 'null/undefined' : vocabularyData.words == null ? 'defined but missing .words' : 'defined'));
-          case 2:
-            firstTokenToWords = new Map(Object.entries(firstTokenToWordsData).map(function (_ref2) {
+            continuationTokensData = _context.sent;
+            surfaceTokenIds = new Map(Object.entries(continuationTokensData !== null && continuationTokensData !== void 0 ? continuationTokensData : {}).map(function (_ref2) {
               var _ref3 = _slicedToArray(_ref2, 2),
-                tokenId = _ref3[0],
-                words = _ref3[1];
-              return [Number(tokenId), words];
+                surface = _ref3[0],
+                tokenIds = _ref3[1];
+              return [surface.toLowerCase(), tokenIds];
             }));
-            l2Words = new Set(Object.keys(vocabularyData.words));
-            prefixMapTokenIds = Array.from(firstTokenToWords.keys());
+            surfaceTokenTrie = new CanonicalSurfaceTokenTrie(surfaceTokenIds.entries());
             if (isAutocompleteDebugEnabled()) {
               // eslint-disable-next-line no-console
-              console.log('%c[LocalSlowLane] %c✅ BE-parity payload data loaded:', 'color: #9c27b0; font-weight: bold;', 'color: #4caf50; font-weight: bold;', {
-                firstTokenToWordsEntries: firstTokenToWords.size,
-                l2WordsCount: l2Words.size,
-                prefixMapTokenIdsLength: prefixMapTokenIds.length
+              console.log("%c[CTC:model] %c".concat(surfaceTokenIds.size > 0 ? '✅ canonical surface tokens loaded:' : '⚠️ canonical surface tokens unavailable — LM evidence will remain absent:'), 'color: #9c27b0; font-weight: bold;', surfaceTokenIds.size > 0 ? 'color: #4caf50; font-weight: bold;' : 'color: #ff9800; font-weight: bold;', {
+                surfaces: surfaceTokenIds.size
               });
             }
-          case 3:
+          case 2:
           case "end":
             return _context.stop();
         }
@@ -289,225 +288,11 @@ var loadBePayloadData = function loadBePayloadData() {
       // Don't cache a rejected promise — a transient import failure would
       // otherwise prevent the local model from ever initialising again this
       // session. Reset so the next init attempt retries.
-      bePayloadDataPromise = undefined;
+      surfaceTokenIdsPromise = undefined;
       throw e;
     });
   }
-  return bePayloadDataPromise;
-};
-
-/**
- * Convert a raw next-token logit vector into a whole-word probability payload,
- * faithfully porting the BE `CausalLMEncoder._get_top_k_probs`
- * (`cc-smarts/python-sidecar/src/causal_lm_encoder.py`).
- *
- * Steps: (1) numerically-stable masked softmax over only the token ids present
- * in the prefix-expansion map; (2) spread each token's probability to every
- * whole word sharing that first token, taking the max; (3) reserve the top L2
- * words unconditionally; (4) rank the remainder in a log-space pool with an
- * additive L2 bias; (5) emit raw probabilities for the survivors, lowercased
- * and trimmed at `MIN_PROB`.
- *
- * :params:
- *   rawLogits: Full-vocabulary logits from the LM's single decode step
- *   prefixMap: Map of first-token id to the words starting with that token
- *   domainWords: Set of L2 (domain) words, for tier-aware ranking
- * :returns:
- *   A record of lowercase word to probability — the BE `lm_logits` payload
- */
-export var computeBePayload = function computeBePayload(rawLogits, prefixMap, domainWords) {
-  var validTokenIds = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : prefixMapTokenIds;
-  // 1. Numerically-stable masked softmax over validTokenIds only.
-  var maxLogit = -Infinity;
-  var _iterator = _createForOfIteratorHelper(validTokenIds),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var id = _step.value;
-      var v = rawLogits[id];
-      if (v > maxLogit) {
-        maxLogit = v;
-      }
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
-  }
-  var sumExp = 0;
-  var expByToken = new Map();
-  var _iterator2 = _createForOfIteratorHelper(validTokenIds),
-    _step2;
-  try {
-    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-      var _id = _step2.value;
-      var e = Math.exp(rawLogits[_id] - maxLogit);
-      expByToken.set(_id, e);
-      sumExp += e;
-    }
-
-    // 2. Prefix expansion with max aggregation (probabilities sum to 1 over the
-    //    masked subset, so divide each token's exp by sumExp on the fly).
-  } catch (err) {
-    _iterator2.e(err);
-  } finally {
-    _iterator2.f();
-  }
-  var wordProbs = new Map();
-  var _iterator3 = _createForOfIteratorHelper(prefixMap),
-    _step3;
-  try {
-    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-      var _expByToken$get;
-      var _step3$value = _slicedToArray(_step3.value, 2),
-        _id2 = _step3$value[0],
-        words = _step3$value[1];
-      var _p = sumExp > 0 ? ((_expByToken$get = expByToken.get(_id2)) !== null && _expByToken$get !== void 0 ? _expByToken$get : 0) / sumExp : 0;
-      var _iterator8 = _createForOfIteratorHelper(words),
-        _step8;
-      try {
-        for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
-          var _wordProbs$get2;
-          var _w = _step8.value;
-          var prev = (_wordProbs$get2 = wordProbs.get(_w)) !== null && _wordProbs$get2 !== void 0 ? _wordProbs$get2 : 0;
-          if (_p > prev) {
-            wordProbs.set(_w, _p);
-          }
-        }
-      } catch (err) {
-        _iterator8.e(err);
-      } finally {
-        _iterator8.f();
-      }
-    }
-
-    // 3. Split into L2 / L3 and reserve the top L2 slots unconditionally.
-  } catch (err) {
-    _iterator3.e(err);
-  } finally {
-    _iterator3.f();
-  }
-  var l2Matches = [];
-  var l3Matches = [];
-  var _iterator4 = _createForOfIteratorHelper(wordProbs),
-    _step4;
-  try {
-    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-      var _step4$value = _slicedToArray(_step4.value, 2),
-        _w2 = _step4$value[0],
-        _p2 = _step4$value[1];
-      if (domainWords.has(_w2)) {
-        l2Matches.push([_w2, _p2]);
-      } else {
-        l3Matches.push([_w2, _p2]);
-      }
-    }
-  } catch (err) {
-    _iterator4.e(err);
-  } finally {
-    _iterator4.f();
-  }
-  l2Matches.sort(function (a, b) {
-    return b[1] - a[1];
-  });
-  var reserved = l2Matches.slice(0, BE_PARITY.RESERVED_L2_SLOTS);
-
-  // 4. Pool the leftovers in log space; the L2 bias only affects ranking here.
-  // Words in l2Matches are unique and the array is sorted descending, so the
-  // non-reserved entries are exactly the tail after the reserved prefix — slice
-  // it directly rather than allocating a Set and scanning every entry on this
-  // hot path (runs ~every word boundary while typing).
-  var pool = [];
-  var _iterator5 = _createForOfIteratorHelper(l2Matches.slice(BE_PARITY.RESERVED_L2_SLOTS)),
-    _step5;
-  try {
-    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-      var _step5$value = _slicedToArray(_step5.value, 2),
-        _w3 = _step5$value[0],
-        _p3 = _step5$value[1];
-      pool.push([_w3, Math.log(Math.max(_p3, 1e-10)) + BE_PARITY.L2_BIAS]);
-    }
-  } catch (err) {
-    _iterator5.e(err);
-  } finally {
-    _iterator5.f();
-  }
-  for (var _i = 0, _l3Matches = l3Matches; _i < _l3Matches.length; _i++) {
-    var _l3Matches$_i = _slicedToArray(_l3Matches[_i], 2),
-      w = _l3Matches$_i[0],
-      p = _l3Matches$_i[1];
-    pool.push([w, Math.log(Math.max(p, 1e-10))]);
-  }
-  pool.sort(function (a, b) {
-    return b[1] - a[1];
-  });
-  var remainingSlots = Math.max(0, BE_PARITY.TOP_K_WORDS - reserved.length);
-  var poolWinners = pool.slice(0, remainingSlots);
-
-  // 5. Assemble payload: store RAW probabilities (the bias was ranking-only),
-  // lowercase keys, trimmed at MIN_PROB. Reserved first, then pool winners.
-  // Reserved entries are written first; pool-winner writes must NOT clobber a
-  // reserved entry whose normalised key collides (two source words can
-  // `.trim().toLowerCase()` to the same key — e.g. "Function" vs "function ").
-  // Without the existence guard, a low-probability pool winner would silently
-  // overwrite the (higher-probability) reserved entry, degrading top-K
-  // quality in a way that's invisible from the debug summary.
-  var result = {};
-  var addEntry = function addEntry(word, prob, allowOverwrite) {
-    if (prob <= BE_PARITY.MIN_PROB) {
-      return;
-    }
-    var key = word.trim().toLowerCase();
-    if (!allowOverwrite && key in result) {
-      return;
-    }
-    result[key] = prob;
-  };
-  var _iterator6 = _createForOfIteratorHelper(reserved),
-    _step6;
-  try {
-    for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
-      var _step6$value = _slicedToArray(_step6.value, 2),
-        _w4 = _step6$value[0],
-        _p4 = _step6$value[1];
-      addEntry(_w4, _p4, true);
-    }
-  } catch (err) {
-    _iterator6.e(err);
-  } finally {
-    _iterator6.f();
-  }
-  var _iterator7 = _createForOfIteratorHelper(poolWinners),
-    _step7;
-  try {
-    for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
-      var _wordProbs$get3;
-      var _step7$value = _slicedToArray(_step7.value, 1),
-        _w5 = _step7$value[0];
-      addEntry(_w5, (_wordProbs$get3 = wordProbs.get(_w5)) !== null && _wordProbs$get3 !== void 0 ? _wordProbs$get3 : 0, false);
-    }
-  } catch (err) {
-    _iterator7.e(err);
-  } finally {
-    _iterator7.f();
-  }
-  if (isAutocompleteDebugEnabled()) {
-    var topReserved = reserved.slice(0, 5).map(function (_ref4) {
-      var _ref5 = _slicedToArray(_ref4, 2),
-        w = _ref5[0],
-        p = _ref5[1];
-      return "".concat(w, ":").concat((p * 100).toFixed(2), "%");
-    }).join(', ');
-    var topPool = poolWinners.slice(0, 5).map(function (_ref6) {
-      var _wordProbs$get;
-      var _ref7 = _slicedToArray(_ref6, 1),
-        w = _ref7[0];
-      return "".concat(w, ":").concat((((_wordProbs$get = wordProbs.get(w)) !== null && _wordProbs$get !== void 0 ? _wordProbs$get : 0) * 100).toFixed(2), "%");
-    }).join(', ');
-    // eslint-disable-next-line no-console
-    console.log('%c[computeBePayload] %c%d valid tokens → %d words expanded | L2: %d / L3: %d | reserved: %d | pool winners: %d | final: %d words\n  maxLogit(masked): %s | sumExp: %s\n  top reserved L2: %s\n  top pool: %s', 'color: #9c27b0; font-weight: bold;', 'color: inherit;', validTokenIds.length, wordProbs.size, l2Matches.length, l3Matches.length, reserved.length, poolWinners.length, Object.keys(result).length, maxLogit.toFixed(3), sumExp.toFixed(1), topReserved || '(none)', topPool || '(none)');
-  }
-  return result;
+  return surfaceTokenIdsPromise;
 };
 
 // ─── Factory ─────────────────────────────────────────────────────────────────
@@ -523,9 +308,8 @@ export var computeBePayload = function computeBePayload(rawLogits, prefixMap, do
  * const client = createLocalSlowLaneClient({ debounceMs: 300 });
  * // On word boundaries:
  * client.updateContext(docText);
- * // In scoring pipeline:
- * const vec = client.getContextVector();
- * const logits = client.getLmLogits();
+ * // Candidate scoring independently calls
+ * // primeBoundaryLm/requestProgressiveSurfaceScores.
  * // On plugin teardown:
  * client.destroy();
  * ```
@@ -535,6 +319,8 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
   var _config$debounceMs = config.debounceMs,
     debounceMs = _config$debounceMs === void 0 ? DEFAULT_DEBOUNCE_MS : _config$debounceMs,
     onUpdate = config.onUpdate,
+    onBoundaryLmUpdate = config.onBoundaryLmUpdate,
+    onSurfaceScoreUpdate = config.onSurfaceScoreUpdate,
     onStatus = config.onStatus,
     onLoadError = config.onLoadError,
     onLoadSuccess = config.onLoadSuccess,
@@ -544,8 +330,54 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
     surface = config.surface;
 
   // ── State ──────────────────────────────────────────────────────────────
+  var storedContextInput = null;
   var storedContextVector = null;
   var storedLmLogits = null;
+  var boundaryCache = new Map();
+  var prefixExpansionCache = new Map();
+  var surfaceScoreCache = new Map();
+  var causalInFlight = false;
+  var inFlightBoundaryContextKey = null;
+  var latestCausalFamilyKey = '';
+  var causalRequestsThisFamily = 0;
+  var causalGeneratedTokensThisFamily = 0;
+  var tierAPrimeCacheHitsThisFamily = 0;
+  var tierAPrimeCacheMissesThisFamily = 0;
+  var causalInferenceOrdinal = 0;
+  var causalInferenceByContext = new Map();
+  var causalInferenceByFamily = new Map();
+  var exactEvidenceCountByContext = new Map();
+  var pendingBoundaryPrimes = new Map();
+  var pendingPrefixExpansions = new Map();
+  var inFlightPrefixExpansions = new Set();
+  // The engine holds exactly one linear KV sequence. WebLLM lets us extend it
+  // (`forwardTokensAndSample`) or drop it (a text completion always resets
+  // first), but never fork or rewind it. Tracking what is currently
+  // materialised is what makes decoding continuous: expanding a token prefix
+  // that extends `kvPath` costs a single decode step, while any other prefix
+  // costs a fresh prompt prefill.
+  var kvContextKey = null;
+  var kvPath = [];
+  var isPrefixOf = function isPrefixOf(prefix, path) {
+    return prefix.length <= path.length && prefix.every(function (token, index) {
+      return token === path[index];
+    });
+  };
+  /**
+   * Whether running this expansion would extend the sequence the engine is
+   * already holding rather than discarding it for a fresh prompt prefill.
+   *
+   * `planProgressiveExpansion` also prefers a warm group, but it decides when
+   * the work is queued and the queue is drained later. A boundary prime or
+   * another context's expansion running in between moves the path out from
+   * under that choice, so the preference has to be re-checked at the moment
+   * something is picked up.
+   */
+  var extendsLiveKvPath = function extendsLiveKvPath(request) {
+    return kvContextKey === request.contextKey && isPrefixOf(kvPath, request.tokenPrefix);
+  };
+  var progressiveRequests = new Map();
+  var progressivePrefixesByContext = new Map();
   var debounceTimer = null;
   var lastRequestedText = '';
   var requestCounter = 0;
@@ -563,14 +395,12 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
   var initFailed = false;
   var engine = null;
   var engineInitPromise = null;
-  // Captures raw next-token logits from the LM's single decode step. Registered
-  // with the engine below; `lmLogitsCapture.captured` is consumed in a later step.
-  var lmLogitsCapture = new CapturingLogitProcessor();
+  var causalLogitProcessor = new CanonicalLogitProcessor();
   var unloadEngine = function unloadEngine(engineToUnload) {
     engineToUnload.unload().catch(function (error) {
       if (isAutocompleteDebugEnabled()) {
         // eslint-disable-next-line no-console
-        console.log('%c[LocalSlowLane] %cFailed to unload engine', 'color: #9c27b0; font-weight: bold;', 'color: inherit;', error);
+        console.log('%c[CTC:model] %cFailed to unload engine', 'color: #9c27b0; font-weight: bold;', 'color: inherit;', error);
       }
     });
   };
@@ -581,7 +411,7 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
     var message = "[".concat((progress.progress * 100).toFixed(0), "%] ").concat(progress.text);
     if (isAutocompleteDebugEnabled()) {
       // eslint-disable-next-line no-console
-      console.log("%c[LocalSlowLane] %c\uD83D\uDD04 ".concat(message), 'color: #9c27b0; font-weight: bold;', 'color: inherit;');
+      console.log("%c[CTC:model] %c\uD83D\uDD04 ".concat(message), 'color: #9c27b0; font-weight: bold;', 'color: inherit;');
     }
     onStatus === null || onStatus === void 0 || onStatus(message);
   };
@@ -594,8 +424,8 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
    * to a concrete hardware/browser limitation rather than a generic error.
    */
   var probeWebGpuCapabilities = /*#__PURE__*/function () {
-    var _ref8 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
-      var gpu, _adapter$limits, _adapter$limits2, adapter, vendor, architecture, _info, _requestAdapterInfo, _ref9, info, _t, _t2, _t3;
+    var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+      var gpu, _adapter$limits, _adapter$limits2, adapter, vendor, architecture, _info, _requestAdapterInfo, _ref5, info, _t, _t2, _t3;
       return _regeneratorRuntime.wrap(function (_context2) {
         while (1) switch (_context2.prev = _context2.next) {
           case 0:
@@ -632,7 +462,7 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
             break;
           case 4:
             _context2.next = 5;
-            return (_requestAdapterInfo = (_ref9 = adapter).requestAdapterInfo) === null || _requestAdapterInfo === void 0 ? void 0 : _requestAdapterInfo.call(_ref9);
+            return (_requestAdapterInfo = (_ref5 = adapter).requestAdapterInfo) === null || _requestAdapterInfo === void 0 ? void 0 : _requestAdapterInfo.call(_ref5);
           case 5:
             _t = _context2.sent;
           case 6:
@@ -668,7 +498,7 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
       }, _callee2, null, [[1, 9], [3, 7]]);
     }));
     return function probeWebGpuCapabilities() {
-      return _ref8.apply(this, arguments);
+      return _ref4.apply(this, arguments);
     };
   }();
 
@@ -710,7 +540,7 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
     var message = LOAD_FAILURE_MESSAGE[reason];
     if (isAutocompleteDebugEnabled()) {
       // eslint-disable-next-line no-console
-      console.log("[LocalSlowLane] Engine initialisation failed (".concat(reason, "): ").concat(debugDetail !== null && debugDetail !== void 0 ? debugDetail : message));
+      console.log("[CTC:model] Engine initialisation failed (".concat(reason, "): ").concat(debugDetail !== null && debugDetail !== void 0 ? debugDetail : message));
     }
     onStatus === null || onStatus === void 0 || onStatus("Engine initialisation failed: ".concat(message));
     onLoadError === null || onLoadError === void 0 || onLoadError({
@@ -724,8 +554,8 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
     initFailed = true;
   };
   var initEngine = /*#__PURE__*/function () {
-    var _ref0 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
-      var capabilities, startTime, _yield$Promise$all3, _yield$Promise$all4, _yield$Promise$all4$, MLCEngineCtor, prebuiltAppConfig, customModelRecord, appConfig, newEngine, loadDurationMs, errorMsg, _t4;
+    var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+      var capabilities, startTime, _yield$Promise$all, _yield$Promise$all2, _yield$Promise$all2$, MLCEngineCtor, prebuiltAppConfig, customModelRecord, appConfig, newEngine, loadDurationMs, errorMsg, _t4;
       return _regeneratorRuntime.wrap(function (_context3) {
         while (1) switch (_context3.prev = _context3.next) {
           case 0:
@@ -758,20 +588,20 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
             _context3.prev = 5;
             if (isAutocompleteDebugEnabled()) {
               // eslint-disable-next-line no-console
-              console.log("%c[LocalSlowLane] %c\uD83D\uDE80 Initialising MLC engine with models: ".concat(modelId, " (LM) + ").concat(LOCAL_MLC_EMBEDDING_MODEL_ID, " (embedder)"), 'color: #9c27b0; font-weight: bold;', 'color: inherit;');
+              console.log("%c[CTC:model] %c\uD83D\uDE80 Initialising MLC engine with models: ".concat(modelId, " (LM) + ").concat(LOCAL_MLC_EMBEDDING_MODEL_ID, " (embedder)"), 'color: #9c27b0; font-weight: bold;', 'color: inherit;');
             }
             onStatus === null || onStatus === void 0 || onStatus("Initialising models: ".concat(modelId, " + ").concat(LOCAL_MLC_EMBEDDING_MODEL_ID, "\u2026"));
 
-            // Fetch the web-llm runtime and the BE-parity lookup tables in parallel;
+            // Fetch the web-llm runtime and canonical token artifact in parallel;
             // both are dynamically imported so they stay out of the main editor chunk.
             _context3.next = 6;
-            return Promise.all([import( /* webpackChunkName: "@atlaskit-internal_editor-plugin-autocomplete-mlc-web-llm" */'@mlc-ai/web-llm'), loadBePayloadData()]);
+            return Promise.all([import( /* webpackChunkName: "@atlaskit-internal_editor-plugin-autocomplete-mlc-web-llm" */'@mlc-ai/web-llm'), loadCanonicalSurfaceTokens()]);
           case 6:
-            _yield$Promise$all3 = _context3.sent;
-            _yield$Promise$all4 = _slicedToArray(_yield$Promise$all3, 1);
-            _yield$Promise$all4$ = _yield$Promise$all4[0];
-            MLCEngineCtor = _yield$Promise$all4$.MLCEngine;
-            prebuiltAppConfig = _yield$Promise$all4$.prebuiltAppConfig;
+            _yield$Promise$all = _context3.sent;
+            _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 1);
+            _yield$Promise$all2$ = _yield$Promise$all2[0];
+            MLCEngineCtor = _yield$Promise$all2$.MLCEngine;
+            prebuiltAppConfig = _yield$Promise$all2$.prebuiltAppConfig;
             customModelRecord = customModelConfig ? _objectSpread(_objectSpread({
               model: customModelConfig.model,
               model_id: modelId,
@@ -793,7 +623,7 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
             newEngine = new MLCEngineCtor({
               appConfig: appConfig,
               initProgressCallback: initProgressCallback,
-              logitProcessorRegistry: new Map([[modelId, lmLogitsCapture]])
+              logitProcessorRegistry: new Map([[modelId, causalLogitProcessor]])
             });
             _context3.next = 7;
             return newEngine.reload([modelId, LOCAL_MLC_EMBEDDING_MODEL_ID]);
@@ -811,13 +641,13 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
             loadDurationMs = Math.round(performance.now() - startTime);
             if (isAutocompleteDebugEnabled()) {
               // eslint-disable-next-line no-console
-              console.log('%c[LocalSlowLane] %c✅ Both models loaded and ready', 'color: #9c27b0; font-weight: bold;', 'color: #4caf50;');
+              console.log('%c[CTC:model] %c✅ Both models loaded and ready', 'color: #9c27b0; font-weight: bold;', 'color: #4caf50;');
               // One-time identity summary so you can confirm which models are active
               // without digging through the init-progress scroll.
               // eslint-disable-next-line no-console
-              console.log('%c[LocalSlowLane] %c🧠 Causal LM    →', 'color: #9c27b0; font-weight: bold;', 'color: #2196f3; font-weight: bold;', modelId);
+              console.log('%c[CTC:model] %c🧠 Causal LM    →', 'color: #9c27b0; font-weight: bold;', 'color: #2196f3; font-weight: bold;', modelId);
               // eslint-disable-next-line no-console
-              console.log('%c[LocalSlowLane] %c🔢 Embedder     →', 'color: #9c27b0; font-weight: bold;', 'color: #009688; font-weight: bold;', LOCAL_MLC_EMBEDDING_MODEL_ID);
+              console.log('%c[CTC:model] %c🔢 Embedder     →', 'color: #9c27b0; font-weight: bold;', 'color: #009688; font-weight: bold;', LOCAL_MLC_EMBEDDING_MODEL_ID);
             }
             onStatus === null || onStatus === void 0 || onStatus('Model loaded and ready.');
             onLoadSuccess === null || onLoadSuccess === void 0 || onLoadSuccess({
@@ -840,7 +670,7 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
       }, _callee3, null, [[5, 9]]);
     }));
     return function initEngine() {
-      return _ref0.apply(this, arguments);
+      return _ref6.apply(this, arguments);
     };
   }();
   var ensureEngineInitialized = function ensureEngineInitialized() {
@@ -855,53 +685,25 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
 
   // ── Inference ──────────────────────────────────────────────────────────
 
-  /**
-   * Run a single forward pass to produce the BE-parity slow-lane outputs.
-   *
-   * Two calls run in parallel on the shared engine:
-   *   - `completions.create({ max_tokens: 1 })` runs the causal LM for exactly
-   *     one decode step. We ignore the generated text; the LogitProcessor
-   *     captures the raw next-token logits during that step, which we turn into
-   *     a whole-word payload via `computeBePayload`.
-   *   - `embeddings.create(...)` runs the Arctic embedder to produce the real
-   *     384-d semantic vector (passage-encoded; see `wrapForArctic`).
-   */
+  /** Run the boundary-timed Arctic semantic inference independently of the LM. */
   var runInference = /*#__PURE__*/function () {
-    var _ref1 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(text, requestId) {
-      var experienceId, lmText, semanticText, arcticInput, captureCompletionTime, _data, tStart, tLmDone, tEmbDone, _yield$Promise$all5, _yield$Promise$all6, embeddingResponse, rawLogits, payload, embedding, sumSq, i, topTokens, errorMsg, _t5;
+    var _ref7 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(text, requestId) {
+      var experienceId, semanticText, arcticInput, _data, tStart, embeddingResponse, tEmbDone, embedding, sumSq, i, errorMsg, _t5;
       return _regeneratorRuntime.wrap(function (_context4) {
         while (1) switch (_context4.prev = _context4.next) {
           case 0:
-            captureCompletionTime = function _captureCompletionTim(promise, onResolved) {
-              return promise.then(function (value) {
-                onResolved(performance.now());
-                return value;
-              });
-            };
             if (!(!engine || destroyed)) {
               _context4.next = 1;
               break;
             }
             return _context4.abrupt("return");
           case 1:
-            experienceId = String(requestId); // Clear the capture buffer so we read only this pass's logits. The engine
-            // serialises per-model requests and updateContext is debounced, so the
-            // latest request's decode step is the last to populate `captured` before
-            // we read it below; stale requests bail on the latestRequestId guard.
-            lmLogitsCapture.resetState();
-
-            // Apply BE-parity rolling-window truncation before both encoders.
-            // BE semantic: last max_context_words words (typeahead_context_encoding.py:36)
-            // BE causal LM: last max_context_tokens BPE tokens (causal_lm_encoder.py:194–198),
-            //               approximated here with word count (no tokenizer available on FE).
-            lmText = truncateToLastNWords(text, BE_PARITY.MAX_CONTEXT_TOKENS);
-            semanticText = truncateToLastNWords(text, BE_PARITY.MAX_CONTEXT_WORDS);
+            experienceId = String(requestId);
+            semanticText = truncateToLastNWords(text, LOCAL_INFERENCE.MAX_CONTEXT_WORDS);
             arcticInput = wrapForArctic(semanticText);
-            if (isAutocompleteDebugEnabled()) {
-              // eslint-disable-next-line no-console
-              console.log("%c[LocalSlowLane] %c\uD83D\uDD22 Arctic input (".concat(arcticInput.length, " chars, ").concat(splitOnWhitespace(semanticText).length, " words): \"").concat(arcticInput.length > 100 ? "".concat(arcticInput.slice(0, 100), "\u2026") : arcticInput, "\""), 'color: #9c27b0; font-weight: bold;', 'color: #009688;');
+            if (isAutocompleteDebugVerbose()) {
               // eslint-disable-next-line no-console
-              console.log("%c[LocalSlowLane] %c\uD83E\uDDE0 LM input (".concat(lmText.length, " chars, ").concat(splitOnWhitespace(lmText).length, " words): \"").concat(lmText.length > 100 ? "".concat(lmText.slice(0, 100), "\u2026") : lmText, "\""), 'color: #9c27b0; font-weight: bold;', 'color: #2196f3;');
+              console.log("%c[CTC:model] %c\uD83D\uDD22 Arctic input (".concat(arcticInput.length, " chars, ").concat(splitOnWhitespace(semanticText).length, " words): \"").concat(arcticInput.length > 100 ? "".concat(arcticInput.slice(0, 100), "\u2026") : arcticInput, "\""), 'color: #9c27b0; font-weight: bold;', 'color: #009688;');
             }
             _context4.prev = 2;
             // Reuse the network slow-lane-fetch UFO experience (tagged isLocalLLM:true,
@@ -917,30 +719,17 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
               surface: surface
             } : {}));
             tStart = performance.now();
-            tLmDone = 0;
-            tEmbDone = 0;
             _context4.next = 3;
-            return Promise.all([captureCompletionTime(engine.completions.create({
-              model: modelId,
-              prompt: lmText,
-              max_tokens: 1,
-              temperature: 0,
-              logprobs: false
-            }), function (resolvedAt) {
-              tLmDone = resolvedAt;
-            }), captureCompletionTime(engine.embeddings.create({
+            return engine.embeddings.create({
               model: LOCAL_MLC_EMBEDDING_MODEL_ID,
               input: arcticInput
-            }), function (resolvedAt) {
-              tEmbDone = resolvedAt;
-            })]);
+            });
           case 3:
-            _yield$Promise$all5 = _context4.sent;
-            _yield$Promise$all6 = _slicedToArray(_yield$Promise$all5, 2);
-            embeddingResponse = _yield$Promise$all6[1];
+            embeddingResponse = _context4.sent;
+            tEmbDone = performance.now();
             if (isAutocompleteDebugEnabled()) {
               // eslint-disable-next-line no-console
-              console.log("%c[LocalSlowLane] %c\u23F1 LM: ".concat((tLmDone - tStart).toFixed(0), "ms | Embedder: ").concat((tEmbDone - tStart).toFixed(0), "ms | Total: ").concat((Math.max(tLmDone, tEmbDone) - tStart).toFixed(0), "ms"), 'color: #9c27b0; font-weight: bold;', 'color: #ff9800;');
+              console.log("%c[CTC:model] %c\u23F1 Embedder: ".concat((tEmbDone - tStart).toFixed(0), "ms"), 'color: #9c27b0; font-weight: bold;', 'color: #ff9800;');
             }
 
             // Discard stale results
@@ -955,24 +744,16 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
             } : {}));
             return _context4.abrupt("return");
           case 4:
-            // ── LM logits: whole-word BE-parity payload ──────────────────
-            rawLogits = lmLogitsCapture.captured;
-            if (rawLogits) {
-              payload = computeBePayload(rawLogits, firstTokenToWords, l2Words);
-              storedLmLogits = Object.keys(payload).length > 0 ? payload : null;
-            } else {
-              storedLmLogits = null;
-            }
-
             // ── Semantic vector: real 384-d Arctic embedding ─────────────
             // Guard against base64-encoded responses (encoding_format: 'base64' would
             // yield a string, and new Float32Array(string) silently produces an empty
             // array, corrupting downstream cosine-similarity scoring).
             embedding = (_data = embeddingResponse.data) === null || _data === void 0 || (_data = _data[0]) === null || _data === void 0 ? void 0 : _data.embedding;
             storedContextVector = Array.isArray(embedding) && embedding.length > 0 ? new Float32Array(embedding) : null;
+            storedContextInput = storedContextVector ? semanticText : null;
             if (isAutocompleteDebugEnabled()) {
               // eslint-disable-next-line no-console
-              console.groupCollapsed("%c[LocalSlowLane] %c\uD83D\uDCE5 Inference result (request #".concat(requestId, ")"), 'color: #9c27b0; font-weight: bold;', 'color: inherit;');
+              console.groupCollapsed("%c[CTC:model] %c\uD83D\uDCE5 Inference result (request #".concat(requestId, ")"), 'color: #9c27b0; font-weight: bold;', 'color: inherit;');
               if (storedContextVector) {
                 sumSq = 0;
                 for (i = 0; i < storedContextVector.length; i++) {
@@ -985,29 +766,14 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
                 console.log('❌ No vector');
               }
               // eslint-disable-next-line no-console
-              console.log(storedLmLogits ? "\u2705 lm_logits: ".concat(Object.keys(storedLmLogits).length, " words") : '❌ No lm_logits');
-              if (storedLmLogits) {
-                topTokens = Object.entries(storedLmLogits).sort(function (_ref10, _ref11) {
-                  var _ref12 = _slicedToArray(_ref10, 2),
-                    a = _ref12[1];
-                  var _ref13 = _slicedToArray(_ref11, 2),
-                    b = _ref13[1];
-                  return b - a;
-                }).slice(0, 10); // eslint-disable-next-line no-console
-                console.log('Top 10 predictions:', topTokens.map(function (_ref14) {
-                  var _ref15 = _slicedToArray(_ref14, 2),
-                    t = _ref15[0],
-                    p = _ref15[1];
-                  return "".concat(t, ": ").concat((p * 100).toFixed(1), "%");
-                }).join(', '));
-              }
+              console.log('🧠 causal LM: independently primed by exact candidate contexts');
               // eslint-disable-next-line no-console
               console.groupEnd();
             }
             succeedExp(EXPERIENCE_NAME.SLOW_LANE_FETCH, experienceId, _objectSpread({
               textLength: text.length,
               hasVector: storedContextVector !== null,
-              hasLmLogits: storedLmLogits !== null,
+              hasLmLogits: false,
               isLocalLLM: true
             }, surface ? {
               surface: surface
@@ -1015,7 +781,7 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
             onUpdate === null || onUpdate === void 0 || onUpdate({
               textLength: text.length,
               hasVector: storedContextVector !== null,
-              hasLmLogits: storedLmLogits !== null
+              hasLmLogits: false
             });
             _context4.next = 7;
             break;
@@ -1033,6 +799,7 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
             } : {}));
             return _context4.abrupt("return");
           case 6:
+            storedContextInput = null;
             storedContextVector = null;
             storedLmLogits = null;
             failExp(EXPERIENCE_NAME.SLOW_LANE_FETCH, experienceId, _objectSpread({
@@ -1049,7 +816,7 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
             errorMsg = _t5 instanceof Error ? _t5.message : String(_t5);
             if (isAutocompleteDebugEnabled()) {
               // eslint-disable-next-line no-console
-              console.log("%c[LocalSlowLane] %c\u274C Inference error (request #".concat(requestId, "): ").concat(errorMsg), 'color: #9c27b0; font-weight: bold;', 'color: #f44336;');
+              console.log("%c[CTC:model] %c\u274C Inference error (request #".concat(requestId, "): ").concat(errorMsg), 'color: #9c27b0; font-weight: bold;', 'color: #f44336;');
             }
           case 7:
           case "end":
@@ -1058,9 +825,859 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
       }, _callee4, null, [[2, 5]]);
     }));
     return function runInference(_x, _x2) {
+      return _ref7.apply(this, arguments);
+    };
+  }();
+
+  // ── Canonical causal scorer ─────────────────────────────────────────────
+
+  var surfaceCacheKey = function surfaceCacheKey(contextKey, surface) {
+    var _surfaceTokenIds$get;
+    var tokenIds = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : (_surfaceTokenIds$get = surfaceTokenIds.get(surface.toLowerCase())) !== null && _surfaceTokenIds$get !== void 0 ? _surfaceTokenIds$get : [];
+    return "".concat(contextKey, "\0").concat(surface.toLowerCase(), "\0").concat(tokenIds.join(','));
+  };
+
+  // Declared as functions rather than generic arrows: this file carries a `webpackChunkName`
+  // comment, which opts it into a build-time parse that reads `<T>(` as a JSX tag.
+  function getLru(cache, key) {
+    var value = cache.get(key);
+    if (value === undefined) {
+      return null;
+    }
+    cache.delete(key);
+    cache.set(key, value);
+    return value;
+  }
+  function setLru(cache, key, value, maxSize) {
+    cache.delete(key);
+    cache.set(key, value);
+    while (cache.size > maxSize) {
+      var oldest = cache.keys().next().value;
+      if (oldest === undefined) {
+        break;
+      }
+      cache.delete(oldest);
+    }
+  }
+  var prefixCacheKey = function prefixCacheKey(contextKey, tokenPrefix) {
+    return "".concat(contextKey, "\0").concat(tokenPrefix.join(','));
+  };
+  var logProgressiveState = function logProgressiveState(state, detail) {
+    if (!isAutocompleteDebugEnabled()) {
+      return;
+    }
+    // eslint-disable-next-line no-console
+    console.log("%c[CTC:model] %c\uD83D\uDD00 grouped ".concat(state, " \xB7 ").concat(detail), 'color: #9c27b0; font-weight: bold;', state === 'failed' ? 'color: #f44336;' : state === 'completed' || state === 'cached' ? 'color: #4caf50;' : 'color: #2196f3;');
+  };
+  var createCausalInferenceAggregate = function createCausalInferenceAggregate(startedAt) {
+    return {
+      e2eLatencyMs: 0,
+      failedRequests: 0,
+      firstStartedAt: startedAt,
+      promptTokens: 0,
+      promptUsageSamples: 0,
+      requestedCompletionTokens: 0,
+      requests: 0,
+      sampledOutputTokens: 0,
+      timeToFirstTokenMs: 0,
+      wallClockMs: 0,
+      webLlmDecodeSteps: 0,
+      webLlmUsageSamples: 0
+    };
+  };
+  var updateCausalInferenceAggregate = function updateCausalInferenceAggregate(cache, key, measurement) {
+    var _getLru;
+    var aggregate = (_getLru = getLru(cache, key)) !== null && _getLru !== void 0 ? _getLru : createCausalInferenceAggregate(performance.now() - measurement.wallClockMs);
+    aggregate.requests++;
+    aggregate.requestedCompletionTokens += measurement.requestedCompletionTokens;
+    aggregate.wallClockMs += measurement.wallClockMs;
+    if (measurement.outcome === 'failed') {
+      aggregate.failedRequests++;
+    }
+    if (measurement.promptTokens !== null) {
+      aggregate.promptTokens += measurement.promptTokens;
+      aggregate.promptUsageSamples++;
+    }
+    if (measurement.sampledOutputTokens !== null && measurement.webLlmDecodeSteps !== null) {
+      aggregate.sampledOutputTokens += measurement.sampledOutputTokens;
+      aggregate.webLlmDecodeSteps += measurement.webLlmDecodeSteps;
+      aggregate.webLlmUsageSamples++;
+    }
+    if (measurement.timeToFirstTokenMs !== null) {
+      aggregate.timeToFirstTokenMs += measurement.timeToFirstTokenMs;
+    }
+    if (measurement.e2eLatencyMs !== null) {
+      aggregate.e2eLatencyMs += measurement.e2eLatencyMs;
+    }
+    setLru(cache, key, aggregate, CANONICAL_SCORING.BOUNDARY_CACHE_MAX);
+    return aggregate;
+  };
+  var causalAggregateForLog = function causalAggregateForLog(aggregate) {
+    return {
+      calls: aggregate.requests,
+      elapsedMs: Number((performance.now() - aggregate.firstStartedAt).toFixed(1)),
+      failedCalls: aggregate.failedRequests,
+      inferenceWallMs: Number(aggregate.wallClockMs.toFixed(1)),
+      promptTokens: aggregate.promptUsageSamples > 0 ? aggregate.promptTokens : 'unreported',
+      requestedOutputTokens: aggregate.requestedCompletionTokens,
+      sampledOutputTokens: aggregate.webLlmUsageSamples > 0 ? aggregate.sampledOutputTokens : 'unreported',
+      timeToFirstTokenMs: aggregate.timeToFirstTokenMs > 0 ? Number(aggregate.timeToFirstTokenMs.toFixed(1)) : 'unreported',
+      webLlmE2eMs: aggregate.e2eLatencyMs > 0 ? Number(aggregate.e2eLatencyMs.toFixed(1)) : 'unreported',
+      webLlmDecodeSteps: aggregate.webLlmUsageSamples > 0 ? aggregate.webLlmDecodeSteps : 'unreported'
+    };
+  };
+  var recordCausalInference = function recordCausalInference(measurement) {
+    var _measurement$promptTo, _measurement$sampledO, _measurement$webLlmDe, _measurement$timeToFi, _measurement$timeToFi2;
+    if (!isAutocompleteDebugEnabled()) {
+      return;
+    }
+    var familyAggregate = updateCausalInferenceAggregate(causalInferenceByFamily, measurement.familyKey, measurement);
+    var contextAggregate = updateCausalInferenceAggregate(causalInferenceByContext, measurement.contextKey, measurement);
+    // One line plus two nested objects per LM call is heavy enough to distort
+    // the latencies it reports, so keep the per-call breakdown behind verbose.
+    if (!isAutocompleteDebugVerbose()) {
+      return;
+    }
+    // eslint-disable-next-line no-console
+    console.log("%c[CTC:model-cost]%c ".concat(measurement.kind, " ").concat(measurement.outcome, " \xB7 ").concat(measurement.wallClockMs.toFixed(1), "ms \xB7 prompt ").concat((_measurement$promptTo = measurement.promptTokens) !== null && _measurement$promptTo !== void 0 ? _measurement$promptTo : '?', " tok/").concat(measurement.promptWords, " words \xB7 output ").concat((_measurement$sampledO = measurement.sampledOutputTokens) !== null && _measurement$sampledO !== void 0 ? _measurement$sampledO : '?', " sampled/").concat(measurement.requestedCompletionTokens, " requested \xB7 decode ").concat((_measurement$webLlmDe = measurement.webLlmDecodeSteps) !== null && _measurement$webLlmDe !== void 0 ? _measurement$webLlmDe : '?', " step").concat(measurement.webLlmDecodeSteps === 1 ? '' : 's', " \xB7 TTFT ").concat((_measurement$timeToFi = (_measurement$timeToFi2 = measurement.timeToFirstTokenMs) === null || _measurement$timeToFi2 === void 0 ? void 0 : _measurement$timeToFi2.toFixed(1)) !== null && _measurement$timeToFi !== void 0 ? _measurement$timeToFi : '?', "ms \xB7 ").concat(measurement.warmState), CTC_STYLES.section, CTC_STYLES.body, {
+      request: {
+        contextKey: measurement.contextKey,
+        familyKey: measurement.familyKey,
+        kind: measurement.kind,
+        outcome: measurement.outcome,
+        warmState: measurement.warmState
+      },
+      actual: {
+        decodeTokensPerSecond: measurement.decodeTokensPerSecond,
+        e2eLatencyMs: measurement.e2eLatencyMs,
+        prefillTokensPerSecond: measurement.prefillTokensPerSecond,
+        promptTokens: measurement.promptTokens,
+        promptWords: measurement.promptWords,
+        sampledOutputTokens: measurement.sampledOutputTokens,
+        timePerDecodeTokenMs: measurement.timePerDecodeTokenMs,
+        timeToFirstTokenMs: measurement.timeToFirstTokenMs,
+        wallClockMs: measurement.wallClockMs,
+        webLlmDecodeSteps: measurement.webLlmDecodeSteps
+      },
+      context: causalAggregateForLog(contextAggregate),
+      family: causalAggregateForLog(familyAggregate)
+    });
+  };
+
+  /**
+   * Pull the captured distribution out of the processor, timing the handover.
+   *
+   * Every call yields one array the width of the vocabulary. If that width is
+   * large and the handover is slow, thousands of calls per session turn into
+   * allocation churn that shows up as latency without any model work behind it.
+   */
+  var captureLogits = function captureLogits() {
+    return causalLogitProcessor.getCapturedLogits();
+  };
+  var createMeasuredCausalCompletion = /*#__PURE__*/function () {
+    var _ref8 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(activeEngine, input) {
+      var prompt, promptWords, startedAt, warmState, _usage$completion_tok, _usage$extra$decode_t, _usage$extra, _usage$extra2, _usage$extra$prefill_, _usage$extra3, _usage$prompt_tokens, _usage$extra4, _usage$extra5, completion, latencyMs, usage, webLlmDecodeSteps, sampledOutputTokens, _latencyMs, _t6;
+      return _regeneratorRuntime.wrap(function (_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
+          case 0:
+            prompt = truncateToLastNWords(input.prompt, LOCAL_INFERENCE.MAX_CONTEXT_TOKENS);
+            promptWords = splitOnWhitespace(prompt).length;
+            startedAt = performance.now();
+            warmState = ++causalInferenceOrdinal === 1 ? 'cold-first-call' : 'warm';
+            _context5.prev = 1;
+            _context5.next = 2;
+            return activeEngine.completions.create({
+              model: modelId,
+              prompt: prompt,
+              max_tokens: input.requestedCompletionTokens,
+              temperature: 0,
+              logprobs: false,
+              ignore_eos: true
+            });
+          case 2:
+            completion = _context5.sent;
+            latencyMs = performance.now() - startedAt;
+            usage = completion.usage;
+            webLlmDecodeSteps = (_usage$completion_tok = usage === null || usage === void 0 ? void 0 : usage.completion_tokens) !== null && _usage$completion_tok !== void 0 ? _usage$completion_tok : null; // WebLLM samples the first output token during prefill, but its
+            // completion_tokens usage counter increments only in decodeStep().
+            // Add that prefill-sampled token back without exceeding max_tokens.
+            sampledOutputTokens = webLlmDecodeSteps === null ? null : Math.min(input.requestedCompletionTokens, webLlmDecodeSteps + 1);
+            recordCausalInference({
+              contextKey: input.contextKey,
+              decodeTokensPerSecond: (_usage$extra$decode_t = usage === null || usage === void 0 || (_usage$extra = usage.extra) === null || _usage$extra === void 0 ? void 0 : _usage$extra.decode_tokens_per_s) !== null && _usage$extra$decode_t !== void 0 ? _usage$extra$decode_t : null,
+              e2eLatencyMs: (usage === null || usage === void 0 || (_usage$extra2 = usage.extra) === null || _usage$extra2 === void 0 ? void 0 : _usage$extra2.e2e_latency_s) !== undefined ? usage.extra.e2e_latency_s * 1000 : null,
+              familyKey: input.familyKey,
+              kind: input.kind,
+              outcome: 'completed',
+              prefillTokensPerSecond: (_usage$extra$prefill_ = usage === null || usage === void 0 || (_usage$extra3 = usage.extra) === null || _usage$extra3 === void 0 ? void 0 : _usage$extra3.prefill_tokens_per_s) !== null && _usage$extra$prefill_ !== void 0 ? _usage$extra$prefill_ : null,
+              promptTokens: (_usage$prompt_tokens = usage === null || usage === void 0 ? void 0 : usage.prompt_tokens) !== null && _usage$prompt_tokens !== void 0 ? _usage$prompt_tokens : null,
+              promptWords: promptWords,
+              requestedCompletionTokens: input.requestedCompletionTokens,
+              sampledOutputTokens: sampledOutputTokens,
+              timePerDecodeTokenMs: (usage === null || usage === void 0 || (_usage$extra4 = usage.extra) === null || _usage$extra4 === void 0 ? void 0 : _usage$extra4.time_per_output_token_s) !== undefined ? usage.extra.time_per_output_token_s * 1000 : null,
+              timeToFirstTokenMs: (usage === null || usage === void 0 || (_usage$extra5 = usage.extra) === null || _usage$extra5 === void 0 ? void 0 : _usage$extra5.time_to_first_token_s) !== undefined ? usage.extra.time_to_first_token_s * 1000 : null,
+              wallClockMs: latencyMs,
+              warmState: warmState,
+              webLlmDecodeSteps: webLlmDecodeSteps
+            });
+            return _context5.abrupt("return", {
+              latencyMs: latencyMs
+            });
+          case 3:
+            _context5.prev = 3;
+            _t6 = _context5["catch"](1);
+            _latencyMs = performance.now() - startedAt;
+            recordCausalInference({
+              contextKey: input.contextKey,
+              decodeTokensPerSecond: null,
+              e2eLatencyMs: null,
+              familyKey: input.familyKey,
+              kind: input.kind,
+              outcome: 'failed',
+              prefillTokensPerSecond: null,
+              promptTokens: null,
+              promptWords: promptWords,
+              requestedCompletionTokens: input.requestedCompletionTokens,
+              sampledOutputTokens: null,
+              timePerDecodeTokenMs: null,
+              timeToFirstTokenMs: null,
+              wallClockMs: _latencyMs,
+              warmState: warmState,
+              webLlmDecodeSteps: null
+            });
+            throw _t6;
+          case 4:
+          case "end":
+            return _context5.stop();
+        }
+      }, _callee5, null, [[1, 3]]);
+    }));
+    return function createMeasuredCausalCompletion(_x3, _x4) {
+      return _ref8.apply(this, arguments);
+    };
+  }();
+  var logExactEvidenceReadiness = function logExactEvidenceReadiness(contextKey, familyKey, exactSurfaceCount, source) {
+    var _exactEvidenceCountBy;
+    if (!isAutocompleteDebugEnabled()) {
+      return;
+    }
+    var previousCount = (_exactEvidenceCountBy = exactEvidenceCountByContext.get(contextKey)) !== null && _exactEvidenceCountBy !== void 0 ? _exactEvidenceCountBy : 0;
+    if (exactSurfaceCount <= previousCount) {
+      return;
+    }
+    setLru(exactEvidenceCountByContext, contextKey, exactSurfaceCount, CANONICAL_SCORING.BOUNDARY_CACHE_MAX);
+    var contextAggregate = getLru(causalInferenceByContext, contextKey);
+    var familyAggregate = getLru(causalInferenceByFamily, familyKey);
+    // eslint-disable-next-line no-console
+    console.log("%c[CTC:readiness]%c exact evidence \xB7 ".concat(exactSurfaceCount, " surface").concat(exactSurfaceCount === 1 ? '' : 's', " \xB7 source=").concat(source, " \xB7 ctx=").concat(contextKey.slice(0, 64)), CTC_STYLES.good, CTC_STYLES.body, {
+      context: contextAggregate ? causalAggregateForLog(contextAggregate) : null,
+      contextKey: contextKey,
+      exactSurfaceCount: exactSurfaceCount,
+      family: familyAggregate ? causalAggregateForLog(familyAggregate) : null,
+      familyKey: familyKey,
+      source: source
+    });
+  };
+  var getProgressiveEvidence = function getProgressiveEvidence(contextKey, candidateSurface) {
+    var _surfaceTokenTrie$get;
+    var tokenIds = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : (_surfaceTokenTrie$get = surfaceTokenTrie.getTokenIds(candidateSurface)) !== null && _surfaceTokenTrie$get !== void 0 ? _surfaceTokenTrie$get : [];
+    if (tokenIds.length === 0) {
+      return null;
+    }
+    var exactKey = surfaceCacheKey(contextKey, candidateSurface, tokenIds);
+    var exact = getLru(surfaceScoreCache, exactKey);
+    if (exact) {
+      return {
+        meanTokenLogProbabilityUpperBound: exact.meanTokenLogProbability,
+        scoredTokenCount: exact.tokenCount,
+        totalLogProbability: exact.totalLogProbability,
+        totalTokenCount: exact.tokenCount
+      };
+    }
+    var boundary = getLru(boundaryCache, contextKey);
+    var firstToken = tokenIds[0];
+    if (!boundary || firstToken === undefined) {
+      return null;
+    }
+    var totalLogProbability = logSoftmaxAt(boundary.rawLogits, firstToken);
+    if (!Number.isFinite(totalLogProbability)) {
+      return null;
+    }
+    var scoredTokenCount = 1;
+    while (scoredTokenCount < tokenIds.length) {
+      var prefix = tokenIds.slice(0, scoredTokenCount);
+      var expansion = getLru(prefixExpansionCache, prefixCacheKey(contextKey, prefix));
+      if (!expansion) {
+        break;
+      }
+      var nextTokenLogProbability = logSoftmaxAt(expansion.rawNextTokenLogits, tokenIds[scoredTokenCount]);
+      if (!Number.isFinite(nextTokenLogProbability)) {
+        break;
+      }
+      totalLogProbability = expansion.totalLogProbability + nextTokenLogProbability;
+      scoredTokenCount++;
+    }
+    if (scoredTokenCount === tokenIds.length) {
+      var exactScore = {
+        contextKey: contextKey,
+        surface: candidateSurface,
+        totalLogProbability: totalLogProbability,
+        meanTokenLogProbability: totalLogProbability / tokenIds.length,
+        tokenCount: tokenIds.length
+      };
+      setLru(surfaceScoreCache, exactKey, exactScore, CANONICAL_SCORING.SURFACE_CACHE_MAX);
+    }
+    return {
+      // Every unscored future token has log probability <= 0. Dividing the
+      // scored total by the final token count is therefore a safe optimistic
+      // bound on the eventual mean.
+      meanTokenLogProbabilityUpperBound: totalLogProbability / tokenIds.length,
+      scoredTokenCount: scoredTokenCount,
+      totalLogProbability: totalLogProbability,
+      totalTokenCount: tokenIds.length
+    };
+  };
+  var _planProgressiveExpansion = function planProgressiveExpansion(contextKey) {
+    var _progressivePrefixesB;
+    var request = progressiveRequests.get(contextKey);
+    if (!request || destroyed || !boundaryCache.has(contextKey)) {
+      return;
+    }
+    var eligible = request.candidates.filter(function (candidate) {
+      return candidate.tokenIds.length > 0 && candidate.tokenIds.length <= CANONICAL_SCORING.EXACT_MAX_TARGET_TOKENS;
+    }).map(function (candidate) {
+      return _objectSpread(_objectSpread({}, candidate), {}, {
+        evidence: getProgressiveEvidence(contextKey, candidate.surface, candidate.tokenIds)
+      });
+    }).filter(function (candidate) {
+      return candidate.evidence !== null;
+    });
+
+    // Score candidates the way arbitration will: a posterior over sequence
+    // log-likelihoods, blended with the corpus prior at the shipped weights.
+    //
+    // Sharing the rule is the point. Ranking on `exp(per-token mean)` instead
+    // answers a different question — it favours short surfaces, because
+    // dividing by fewer tokens flatters them — so this scheduler used to stop
+    // reading on a margin the decision layer did not recognise, and then
+    // abstain for want of the very tokens it declined to read. Nothing about
+    // that was visible from either side.
+    //
+    // The normaliser spans every eligible candidate rather than only the
+    // scheduled ones. That can only make each posterior smaller and each margin
+    // narrower, so the error is always towards reading another token instead of
+    // stopping early — the safe direction ahead of a precision-first gate.
+    var normalizer = logSumExp(eligible.map(function (candidate) {
+      return candidate.evidence.totalLogProbability;
+    }));
+    var confidenceScore = function confidenceScore(candidate) {
+      var _candidate$rankHint;
+      return STAGE1_WEIGHT * ((_candidate$rankHint = candidate.rankHint) !== null && _candidate$rankHint !== void 0 ? _candidate$rankHint : 0) + STAGE2_WEIGHT * (Number.isFinite(normalizer) ? Math.exp(candidate.evidence.totalLogProbability - normalizer) : 0);
+    };
+    var candidates = eligible.sort(function (a, b) {
+      return confidenceScore(b) - confidenceScore(a);
+    }).slice(0, CANONICAL_SCORING.PROGRESSIVE_CANDIDATES_MAX);
+    var unresolved = candidates.filter(function (candidate) {
+      return candidate.evidence.scoredTokenCount < candidate.tokenIds.length;
+    });
+    if (unresolved.length === 0) {
+      logProgressiveState('completed', "ctx=".concat(contextKey.slice(0, 48), " \xB7 exact=").concat(candidates.length, "/").concat(candidates.length));
+      return;
+    }
+    var bestExactScore = Math.max.apply(Math, _toConsumableArray(candidates.filter(function (candidate) {
+      return candidate.evidence.scoredTokenCount === candidate.tokenIds.length;
+    }).map(confidenceScore)).concat([-Infinity]));
+    var bestUnresolvedScore = Math.max.apply(Math, _toConsumableArray(unresolved.map(confidenceScore)).concat([-Infinity]));
+    if (bestExactScore - bestUnresolvedScore >= MIN_WINNER_MARGIN) {
+      logProgressiveState('completed', "safe bound \xB7 ctx=".concat(contextKey.slice(0, 40), " \xB7 margin=").concat((bestExactScore - bestUnresolvedScore).toFixed(2), " \xB7 unresolved=").concat(unresolved.length));
+      return;
+    }
+    var groups = surfaceTokenTrie.groupByScoredPrefix(unresolved.map(function (candidate) {
+      return {
+        surface: candidate.surface,
+        tokenIds: candidate.tokenIds,
+        scoredTokenCount: candidate.evidence.scoredTokenCount
+      };
+    }));
+    var bySurface = new Map(candidates.map(function (candidate) {
+      return [candidate.surface, candidate];
+    }));
+    var rankedGroups = groups.map(function (group) {
+      var members = group.surfaces.map(function (candidateSurface) {
+        return bySurface.get(candidateSurface);
+      }).filter(function (candidate) {
+        return Boolean(candidate);
+      });
+      var optimisticScore = Math.max.apply(Math, _toConsumableArray(members.map(confidenceScore)));
+      return _objectSpread(_objectSpread({}, group), {}, {
+        optimisticScore: optimisticScore
+      });
+    }).sort(function (a, b) {
+      return b.optimisticScore - a.optimisticScore;
+    });
+    var bestGroup = rankedGroups[0];
+    if (!bestGroup) {
+      return;
+    }
+    var warmGroup = kvContextKey === contextKey ? rankedGroups.find(function (group) {
+      return isPrefixOf(kvPath, group.tokenPrefix);
+    }) : undefined;
+    var nextGroup = warmGroup && warmGroup.optimisticScore >= bestGroup.optimisticScore - PROGRESSIVE_WARM_PATH_MARGIN ? warmGroup : bestGroup;
+    var contextPrefixes = (_progressivePrefixesB = progressivePrefixesByContext.get(contextKey)) !== null && _progressivePrefixesB !== void 0 ? _progressivePrefixesB : new Set();
+    progressivePrefixesByContext.set(contextKey, contextPrefixes);
+    var key = prefixCacheKey(contextKey, nextGroup.tokenPrefix);
+    if (getLru(prefixExpansionCache, key)) {
+      logProgressiveState('cached', "ctx=".concat(contextKey.slice(0, 40), " \xB7 prefix=[").concat(nextGroup.tokenPrefix.join(','), "]"));
+      _planProgressiveExpansion(contextKey);
+      return;
+    }
+    if (pendingPrefixExpansions.has(key) || inFlightPrefixExpansions.has(key)) {
+      logProgressiveState('deduplicated', "ctx=".concat(contextKey.slice(0, 40), " \xB7 prefix=[").concat(nextGroup.tokenPrefix.join(','), "]"));
+      return;
+    }
+    if (contextPrefixes.size >= CANONICAL_SCORING.PROGRESSIVE_EXPANSIONS_PER_CONTEXT_MAX) {
+      logProgressiveState('completed', "ctx=".concat(contextKey.slice(0, 48), " \xB7 expansion cap=").concat(contextPrefixes.size, " \xB7 unresolved=").concat(unresolved.length));
+      return;
+    }
+    contextPrefixes.add(key);
+    pendingPrefixExpansions.set(key, {
+      contextKey: contextKey,
+      familyKey: request.familyKey,
+      prompt: request.prompt,
+      tokenPrefix: nextGroup.tokenPrefix,
+      surfaces: nextGroup.surfaces
+    });
+    logProgressiveState('queued', "ctx=".concat(contextKey.slice(0, 40), " \xB7 prefix=[").concat(nextGroup.tokenPrefix.join(','), "] \xB7 surfaces=").concat(nextGroup.surfaces.length));
+    _drainCausalQueue();
+  };
+
+  /**
+   * Prefill `prompt` and cache the boundary distribution that follows it.
+   *
+   * A text completion resets the KV cache before prefilling, so asking for a
+   * single token leaves the cache holding exactly the prompt. That is the
+   * anchor every later decode step extends.
+   */
+  var prefillBoundary = /*#__PURE__*/function () {
+    var _ref9 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(activeEngine, request) {
+      var _yield$createMeasured, latencyMs, rawLogits;
+      return _regeneratorRuntime.wrap(function (_context6) {
+        while (1) switch (_context6.prev = _context6.next) {
+          case 0:
+            kvContextKey = null;
+            kvPath = [];
+            causalRequestsThisFamily++;
+            causalGeneratedTokensThisFamily++;
+            causalLogitProcessor.startCapture();
+            _context6.next = 1;
+            return createMeasuredCausalCompletion(activeEngine, {
+              contextKey: request.contextKey,
+              familyKey: request.familyKey,
+              kind: 'boundary',
+              prompt: request.prompt,
+              requestedCompletionTokens: 1
+            });
+          case 1:
+            _yield$createMeasured = _context6.sent;
+            latencyMs = _yield$createMeasured.latencyMs;
+            rawLogits = captureLogits();
+            if (rawLogits) {
+              _context6.next = 2;
+              break;
+            }
+            return _context6.abrupt("return", null);
+          case 2:
+            setLru(boundaryCache, request.contextKey, {
+              contextKey: request.contextKey,
+              prompt: request.prompt,
+              rawLogits: rawLogits
+            }, CANONICAL_SCORING.BOUNDARY_CACHE_MAX);
+            kvContextKey = request.contextKey;
+            kvPath = [];
+            return _context6.abrupt("return", {
+              latencyMs: latencyMs,
+              rawLogits: rawLogits
+            });
+          case 3:
+          case "end":
+            return _context6.stop();
+        }
+      }, _callee6);
+    }));
+    return function prefillBoundary(_x5, _x6) {
+      return _ref9.apply(this, arguments);
+    };
+  }();
+
+  /**
+   * Append one token to the KV cache and return the distribution that follows.
+   *
+   * This deliberately bypasses the completion API: a completion would reset the
+   * cache and re-prefill the whole prompt, whereas this forwards a single token
+   * on top of the work already done.
+   */
+  var decodeOneToken = /*#__PURE__*/function () {
+    var _ref0 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7(activeEngine, token) {
+      var _t7;
+      return _regeneratorRuntime.wrap(function (_context7) {
+        while (1) switch (_context7.prev = _context7.next) {
+          case 0:
+            causalLogitProcessor.startCapture();
+            _context7.prev = 1;
+            _context7.next = 2;
+            return activeEngine.forwardTokensAndSample([token], false, modelId);
+          case 2:
+            _context7.next = 4;
+            break;
+          case 3:
+            _context7.prev = 3;
+            _t7 = _context7["catch"](1);
+            kvContextKey = null;
+            kvPath = [];
+            throw _t7;
+          case 4:
+            causalRequestsThisFamily++;
+            causalGeneratedTokensThisFamily++;
+            return _context7.abrupt("return", captureLogits());
+          case 5:
+          case "end":
+            return _context7.stop();
+        }
+      }, _callee7, null, [[1, 3]]);
+    }));
+    return function decodeOneToken(_x7, _x8) {
+      return _ref0.apply(this, arguments);
+    };
+  }();
+  var runBoundaryPrime = /*#__PURE__*/function () {
+    var _ref1 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee8(request) {
+      var _progressiveRequest$c, _progressiveRequest$f, _progressiveRequests$, _progressiveRequests$2;
+      var primed, latencyMs, rawLogits, progressiveRequest, exactSurfaceCount, callbackFamilyKey;
+      return _regeneratorRuntime.wrap(function (_context8) {
+        while (1) switch (_context8.prev = _context8.next) {
+          case 0:
+            if (!(!engine || destroyed)) {
+              _context8.next = 1;
+              break;
+            }
+            return _context8.abrupt("return");
+          case 1:
+            _context8.next = 2;
+            return prefillBoundary(engine, request);
+          case 2:
+            primed = _context8.sent;
+            if (primed) {
+              _context8.next = 3;
+              break;
+            }
+            return _context8.abrupt("return");
+          case 3:
+            latencyMs = primed.latencyMs, rawLogits = primed.rawLogits;
+            _planProgressiveExpansion(request.contextKey);
+            progressiveRequest = progressiveRequests.get(request.contextKey);
+            exactSurfaceCount = (_progressiveRequest$c = progressiveRequest === null || progressiveRequest === void 0 ? void 0 : progressiveRequest.candidates.filter(function (candidate) {
+              var evidence = getProgressiveEvidence(request.contextKey, candidate.surface, candidate.tokenIds);
+              return evidence !== null && evidence.scoredTokenCount === evidence.totalTokenCount;
+            }).length) !== null && _progressiveRequest$c !== void 0 ? _progressiveRequest$c : 0;
+            logExactEvidenceReadiness(request.contextKey, (_progressiveRequest$f = progressiveRequest === null || progressiveRequest === void 0 ? void 0 : progressiveRequest.familyKey) !== null && _progressiveRequest$f !== void 0 ? _progressiveRequest$f : request.familyKey, exactSurfaceCount, 'boundary');
+            if (isAutocompleteDebugEnabled()) {
+              // eslint-disable-next-line no-console
+              console.log("%c[CTC:model] %c\uD83E\uDDE0 Tier A prime #".concat(request.priority + 1, " \xB7 ctx=").concat(request.contextKey.slice(0, 48), " \xB7 ").concat(rawLogits.length, " logits \xB7 ").concat(latencyMs.toFixed(0), "ms \xB7 family req:").concat(causalRequestsThisFamily, " tok:").concat(causalGeneratedTokensThisFamily, " A hit/miss:").concat(tierAPrimeCacheHitsThisFamily, "/").concat(tierAPrimeCacheMissesThisFamily), 'color: #9c27b0; font-weight: bold;', 'color: #2196f3;');
+            }
+            callbackFamilyKey = (_progressiveRequests$ = (_progressiveRequests$2 = progressiveRequests.get(request.contextKey)) === null || _progressiveRequests$2 === void 0 ? void 0 : _progressiveRequests$2.familyKey) !== null && _progressiveRequests$ !== void 0 ? _progressiveRequests$ : request.familyKey;
+            if (callbackFamilyKey === latestCausalFamilyKey && !destroyed) {
+              onBoundaryLmUpdate === null || onBoundaryLmUpdate === void 0 || onBoundaryLmUpdate({
+                contextKey: request.contextKey,
+                familyKey: callbackFamilyKey,
+                latencyMs: latencyMs
+              });
+            }
+          case 4:
+          case "end":
+            return _context8.stop();
+        }
+      }, _callee8);
+    }));
+    return function runBoundaryPrime(_x9) {
       return _ref1.apply(this, arguments);
     };
   }();
+  var runPrefixExpansion = /*#__PURE__*/function () {
+    var _ref10 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee9(request) {
+      var _progressivePrefixesB2, _progressiveRequest$f2, _progressiveRequests$3, _progressiveRequests$4;
+      var activeEngine, startedAt, logitsAtPath, totalAtPath, pathIsLive, _getLru$rawLogits, _getLru2, _resume$rawNextTokenL, _resume$totalLogProba, resume, primed, contextPrefixes, index, token, stepLogProbability, nextLogits, stepKey, expansion, latencyMs, progressiveRequest, newlyExact, exactSurfaceCount, _iterator, _step, candidate, exactKey, wasExact, evidence, callbackFamilyKey;
+      return _regeneratorRuntime.wrap(function (_context9) {
+        while (1) switch (_context9.prev = _context9.next) {
+          case 0:
+            if (!(!engine || destroyed)) {
+              _context9.next = 1;
+              break;
+            }
+            return _context9.abrupt("return");
+          case 1:
+            activeEngine = engine;
+            startedAt = performance.now();
+            logProgressiveState('started', "ctx=".concat(request.contextKey.slice(0, 40), " \xB7 prefix=[").concat(request.tokenPrefix.join(','), "] \xB7 surfaces=").concat(request.surfaces.length));
+
+            // Resume from whatever the KV cache already holds for this context, and
+            // fall back to a prompt prefill only when the requested prefix branches
+            // away from it.
+            logitsAtPath = null;
+            totalAtPath = 0;
+            pathIsLive = extendsLiveKvPath(request);
+            if (pathIsLive) {
+              if (kvPath.length === 0) {
+                logitsAtPath = (_getLru$rawLogits = (_getLru2 = getLru(boundaryCache, request.contextKey)) === null || _getLru2 === void 0 ? void 0 : _getLru2.rawLogits) !== null && _getLru$rawLogits !== void 0 ? _getLru$rawLogits : null;
+              } else {
+                resume = getLru(prefixExpansionCache, prefixCacheKey(request.contextKey, kvPath));
+                logitsAtPath = (_resume$rawNextTokenL = resume === null || resume === void 0 ? void 0 : resume.rawNextTokenLogits) !== null && _resume$rawNextTokenL !== void 0 ? _resume$rawNextTokenL : null;
+                totalAtPath = (_resume$totalLogProba = resume === null || resume === void 0 ? void 0 : resume.totalLogProbability) !== null && _resume$totalLogProba !== void 0 ? _resume$totalLogProba : 0;
+              }
+            }
+            if (logitsAtPath) {
+              _context9.next = 4;
+              break;
+            }
+            _context9.next = 2;
+            return prefillBoundary(activeEngine, request);
+          case 2:
+            primed = _context9.sent;
+            if (primed) {
+              _context9.next = 3;
+              break;
+            }
+            logProgressiveState('failed', "ctx=".concat(request.contextKey.slice(0, 40), " \xB7 prefix=[").concat(request.tokenPrefix.join(','), "] \xB7 missing boundary logits"));
+            return _context9.abrupt("return");
+          case 3:
+            logitsAtPath = primed.rawLogits;
+            totalAtPath = 0;
+          case 4:
+            // Walking the path caches every depth along it, not just the requested
+            // one, so a later expansion that shares this prefix costs nothing.
+            contextPrefixes = (_progressivePrefixesB2 = progressivePrefixesByContext.get(request.contextKey)) !== null && _progressivePrefixesB2 !== void 0 ? _progressivePrefixesB2 : new Set();
+            progressivePrefixesByContext.set(request.contextKey, contextPrefixes);
+            index = kvPath.length;
+          case 5:
+            if (!(index < request.tokenPrefix.length)) {
+              _context9.next = 11;
+              break;
+            }
+            token = request.tokenPrefix[index];
+            if (!(token === undefined)) {
+              _context9.next = 6;
+              break;
+            }
+            return _context9.abrupt("continue", 11);
+          case 6:
+            stepLogProbability = logSoftmaxAt(logitsAtPath, token);
+            if (Number.isFinite(stepLogProbability)) {
+              _context9.next = 7;
+              break;
+            }
+            logProgressiveState('failed', "ctx=".concat(request.contextKey.slice(0, 40), " \xB7 prefix=[").concat(request.tokenPrefix.join(','), "] \xB7 token ").concat(token, " unscoreable"));
+            return _context9.abrupt("return");
+          case 7:
+            _context9.next = 8;
+            return decodeOneToken(activeEngine, token);
+          case 8:
+            nextLogits = _context9.sent;
+            if (!(!nextLogits || destroyed)) {
+              _context9.next = 9;
+              break;
+            }
+            kvContextKey = null;
+            kvPath = [];
+            logProgressiveState('failed', "ctx=".concat(request.contextKey.slice(0, 40), " \xB7 prefix=[").concat(request.tokenPrefix.join(','), "] \xB7 missing logits"));
+            return _context9.abrupt("return");
+          case 9:
+            kvContextKey = request.contextKey;
+            kvPath = [].concat(_toConsumableArray(kvPath), [token]);
+            totalAtPath += stepLogProbability;
+            logitsAtPath = nextLogits;
+            stepKey = prefixCacheKey(request.contextKey, kvPath);
+            expansion = {
+              contextKey: request.contextKey,
+              tokenPrefix: _toConsumableArray(kvPath),
+              totalLogProbability: totalAtPath,
+              rawNextTokenLogits: nextLogits
+            };
+            setLru(prefixExpansionCache, stepKey, expansion, CANONICAL_SCORING.PREFIX_CACHE_MAX);
+            contextPrefixes.add(stepKey);
+          case 10:
+            index++;
+            _context9.next = 5;
+            break;
+          case 11:
+            latencyMs = performance.now() - startedAt;
+            progressiveRequest = progressiveRequests.get(request.contextKey);
+            newlyExact = 0;
+            exactSurfaceCount = 0;
+            if (progressiveRequest) {
+              _iterator = _createForOfIteratorHelper(progressiveRequest.candidates);
+              try {
+                for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                  candidate = _step.value;
+                  exactKey = surfaceCacheKey(request.contextKey, candidate.surface, candidate.tokenIds);
+                  wasExact = surfaceScoreCache.has(exactKey);
+                  evidence = getProgressiveEvidence(request.contextKey, candidate.surface, candidate.tokenIds);
+                  if (!wasExact && evidence !== null && evidence.scoredTokenCount === evidence.totalTokenCount && surfaceScoreCache.has(exactKey)) {
+                    newlyExact++;
+                  }
+                  if (evidence !== null && evidence.scoredTokenCount === evidence.totalTokenCount) {
+                    exactSurfaceCount++;
+                  }
+                }
+              } catch (err) {
+                _iterator.e(err);
+              } finally {
+                _iterator.f();
+              }
+            }
+            logExactEvidenceReadiness(request.contextKey, (_progressiveRequest$f2 = progressiveRequest === null || progressiveRequest === void 0 ? void 0 : progressiveRequest.familyKey) !== null && _progressiveRequest$f2 !== void 0 ? _progressiveRequest$f2 : request.familyKey, exactSurfaceCount, 'prefix');
+            logProgressiveState('expanded', "ctx=".concat(request.contextKey.slice(0, 40), " \xB7 prefix=[").concat(request.tokenPrefix.join(','), "] \xB7 exact+").concat(newlyExact, " \xB7 ").concat(latencyMs.toFixed(0), "ms"));
+            _planProgressiveExpansion(request.contextKey);
+            callbackFamilyKey = (_progressiveRequests$3 = (_progressiveRequests$4 = progressiveRequests.get(request.contextKey)) === null || _progressiveRequests$4 === void 0 ? void 0 : _progressiveRequests$4.familyKey) !== null && _progressiveRequests$3 !== void 0 ? _progressiveRequests$3 : request.familyKey;
+            if (callbackFamilyKey === latestCausalFamilyKey && !destroyed) {
+              onSurfaceScoreUpdate === null || onSurfaceScoreUpdate === void 0 || onSurfaceScoreUpdate({
+                contextKey: request.contextKey,
+                count: newlyExact,
+                familyKey: callbackFamilyKey,
+                latencyMs: latencyMs
+              });
+            } else {
+              logProgressiveState('stale', "cached only \xB7 ctx=".concat(request.contextKey.slice(0, 40), " \xB7 family=").concat(request.familyKey.slice(0, 32)));
+            }
+          case 12:
+          case "end":
+            return _context9.stop();
+        }
+      }, _callee9);
+    }));
+    return function runPrefixExpansion(_x0) {
+      return _ref10.apply(this, arguments);
+    };
+  }();
+
+  /**
+   * Whether any live decision would still take this request's result.
+   *
+   * Ranking on the family a request was created under, as this used to, misses
+   * in both directions. Work queued a keystroke ago for a context still under
+   * the cursor sorts as stale even though the callbacks resolve delivery
+   * through `progressiveRequests` and would hand it over. Work for a context
+   * nothing asks about any more sorts as runnable even though the same
+   * resolution drops it on arrival — and that one is expensive, because an
+   * abandoned context is never the one the KV cache holds, so running it pays
+   * a prompt prefill and leaves the live context evicted, charging the next
+   * live request a second prefill. Two prefills for a discarded result.
+   *
+   * Either signal alone is enough to keep the work, which matters because a
+   * boundary prime is queued before its context's surfaces are requested: at
+   * that moment the stored family is still the previous decision's, and only
+   * the request's own family says it is current.
+   *
+   * Agreeing with the layer being fed is the correction the expansion planner
+   * already carries for arbitration's scoring rule — a scheduler deciding on
+   * its own rule stops on margins the consumer does not recognise.
+   */
+  var stillWanted = function stillWanted(request) {
+    var _progressiveRequests$5;
+    return request.familyKey === latestCausalFamilyKey || ((_progressiveRequests$5 = progressiveRequests.get(request.contextKey)) === null || _progressiveRequests$5 === void 0 ? void 0 : _progressiveRequests$5.familyKey) === latestCausalFamilyKey;
+  };
+  var _drainCausalQueue = function drainCausalQueue() {
+    if (causalInFlight || destroyed) {
+      return;
+    }
+    // Drop abandoned work rather than leaving it to be picked up whenever the
+    // live family happens to have nothing queued. Its cached side effects are
+    // speculative — they only pay off if the user deletes back into exactly
+    // this context and prefix — and the prefill pair above is certain.
+    var _iterator2 = _createForOfIteratorHelper(pendingPrefixExpansions),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var _step2$value = _slicedToArray(_step2.value, 2),
+          key = _step2$value[0],
+          request = _step2$value[1];
+        if (!stillWanted(request)) {
+          pendingPrefixExpansions.delete(key);
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+    var _iterator3 = _createForOfIteratorHelper(pendingBoundaryPrimes),
+      _step3;
+    try {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        var _step3$value = _slicedToArray(_step3.value, 2),
+          contextKey = _step3$value[0],
+          _request = _step3$value[1];
+        if (!stillWanted(_request)) {
+          pendingBoundaryPrimes.delete(contextKey);
+        }
+      }
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
+    }
+    var sortedPrimes = Array.from(pendingBoundaryPrimes.values()).sort(function (a, b) {
+      return a.priority - b.priority;
+    });
+    // Everything left is wanted, so relevance no longer needs a sort key.
+    // Take whichever request continues the live sequence: that expansion costs
+    // one decode step where any other costs a full prompt prefill, and nothing
+    // is skipped, only reordered.
+    //
+    // Staying inside the live context when nothing continues it was tried and
+    // reverted. It moved re-primes from `reprime-context` to `reprime-branch`
+    // and left the total flat, because both pay for a prompt prefill: a
+    // context whose remaining prefixes diverge at the first token re-primes as
+    // a branch instead of as a context. Ordering cannot recover that; only
+    // queueing fewer divergent branches can, which is what the prune above
+    // does.
+    var sortedPrefixes = Array.from(pendingPrefixExpansions.values()).sort(function (a, b) {
+      return Number(extendsLiveKvPath(b)) - Number(extendsLiveKvPath(a));
+    });
+    var nextPrefix = sortedPrefixes[0];
+    var nextPrime = nextPrefix ? undefined : sortedPrimes[0];
+    if (!nextPrefix && !nextPrime) {
+      return;
+    }
+    causalInFlight = true;
+    var prefixKey = null;
+    if (nextPrefix) {
+      prefixKey = prefixCacheKey(nextPrefix.contextKey, nextPrefix.tokenPrefix);
+      pendingPrefixExpansions.delete(prefixKey);
+      inFlightPrefixExpansions.add(prefixKey);
+    } else if (nextPrime) {
+      pendingBoundaryPrimes.delete(nextPrime.contextKey);
+      inFlightBoundaryContextKey = nextPrime.contextKey;
+    }
+    void ensureEngineInitialized().then(function () {
+      return nextPrefix ? runPrefixExpansion(nextPrefix) : nextPrime ? runBoundaryPrime(nextPrime) : undefined;
+    }).catch(function (error) {
+      if (nextPrefix) {
+        logProgressiveState('failed', "ctx=".concat(nextPrefix.contextKey.slice(0, 40), " \xB7 prefix=[").concat(nextPrefix.tokenPrefix.join(','), "] \xB7 ").concat(error instanceof Error ? error.message : String(error)));
+      }
+      if (isAutocompleteDebugEnabled()) {
+        // eslint-disable-next-line no-console
+        console.log("%c[CTC:model] %c\u274C canonical causal request failed: ".concat(error instanceof Error ? error.message : String(error)), 'color: #9c27b0; font-weight: bold;', 'color: #f44336;');
+      }
+    }).finally(function () {
+      if (prefixKey) {
+        inFlightPrefixExpansions.delete(prefixKey);
+      }
+      if (nextPrime) {
+        inFlightBoundaryContextKey = null;
+      }
+      causalInFlight = false;
+      _drainCausalQueue();
+    });
+  };
 
   // ── Context update (debounced) ─────────────────────────────────────────
 
@@ -1110,7 +1727,7 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
     latestRequestId = requestId;
     if (isAutocompleteDebugEnabled()) {
       // eslint-disable-next-line no-console
-      console.groupCollapsed("%c[LocalSlowLane] %c\uD83D\uDCE4 Context update (request #".concat(requestId, ") | ").concat(text.length, " chars"), 'color: #9c27b0; font-weight: bold;', 'color: inherit;');
+      console.groupCollapsed("%c[CTC:model] %c\uD83D\uDCE4 Context update (request #".concat(requestId, ") | ").concat(text.length, " chars"), 'color: #9c27b0; font-weight: bold;', 'color: inherit;');
       var lines = text.split('\n');
       lines.forEach(function (line, i) {
         // eslint-disable-next-line no-console
@@ -1146,22 +1763,136 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
       doUpdateContext(lastRequestedText);
     }, debounceMs);
   };
+  var setLatestCausalFamily = function setLatestCausalFamily(familyKey) {
+    if (familyKey === latestCausalFamilyKey) {
+      return;
+    }
+    latestCausalFamilyKey = familyKey;
+    causalRequestsThisFamily = 0;
+    causalGeneratedTokensThisFamily = 0;
+    tierAPrimeCacheHitsThisFamily = 0;
+    tierAPrimeCacheMissesThisFamily = 0;
+  };
+  var primeBoundaryLm = function primeBoundaryLm(input) {
+    if (destroyed) {
+      return;
+    }
+    setLatestCausalFamily(input.familyKey);
+    if (getLru(boundaryCache, input.contextKey)) {
+      tierAPrimeCacheHitsThisFamily++;
+      if (isAutocompleteDebugVerbose()) {
+        // eslint-disable-next-line no-console
+        console.log("%c[CTC:model] %c\u26A1 Tier A cache hit \xB7 ctx=".concat(input.contextKey.slice(0, 48)), 'color: #9c27b0; font-weight: bold;', 'color: #2196f3;');
+      }
+      return;
+    }
+    if (pendingBoundaryPrimes.has(input.contextKey) || inFlightBoundaryContextKey === input.contextKey) {
+      logProgressiveState('deduplicated', "boundary \xB7 ctx=".concat(input.contextKey.slice(0, 48)));
+      return;
+    }
+    if (pendingBoundaryPrimes.size >= CANONICAL_SCORING.TIER_A_PRIMES_MAX) {
+      var stalePending = Array.from(pendingBoundaryPrimes.entries()).find(function (_ref11) {
+        var _ref12 = _slicedToArray(_ref11, 2),
+          request = _ref12[1];
+        return request.familyKey !== latestCausalFamilyKey;
+      });
+      if (stalePending) {
+        pendingBoundaryPrimes.delete(stalePending[0]);
+        logProgressiveState('stale', "dropped unstarted boundary \xB7 ctx=".concat(stalePending[0].slice(0, 48)));
+      }
+    }
+    if (pendingBoundaryPrimes.size < CANONICAL_SCORING.TIER_A_PRIMES_MAX) {
+      tierAPrimeCacheMissesThisFamily++;
+      pendingBoundaryPrimes.set(input.contextKey, input);
+    }
+    _drainCausalQueue();
+  };
+  var requestProgressiveSurfaceScores = function requestProgressiveSurfaceScores(input) {
+    if (destroyed) {
+      return;
+    }
+    setLatestCausalFamily(input.familyKey);
+    var candidates = input.candidates.filter(function (candidate) {
+      return candidate.tokenIds.length > 0 && candidate.tokenIds.length <= CANONICAL_SCORING.EXACT_MAX_TARGET_TOKENS;
+    }).slice(0, CANONICAL_SCORING.PROGRESSIVE_INPUT_MAX);
+    if (candidates.length === 0) {
+      return;
+    }
+    var previous = progressiveRequests.get(input.contextKey);
+    var candidateSignature = candidates.map(function (candidate) {
+      return "".concat(candidate.surface, ":").concat(candidate.tokenIds.join(','));
+    }).join("\x01");
+    var previousSignature = previous === null || previous === void 0 ? void 0 : previous.candidates.map(function (candidate) {
+      return "".concat(candidate.surface, ":").concat(candidate.tokenIds.join(','));
+    }).join("\x01");
+    setLru(progressiveRequests, input.contextKey, _objectSpread(_objectSpread({}, input), {}, {
+      candidates: candidates
+    }), CANONICAL_SCORING.BOUNDARY_CACHE_MAX);
+    var _iterator4 = _createForOfIteratorHelper(progressivePrefixesByContext.keys()),
+      _step4;
+    try {
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        var cachedContextKey = _step4.value;
+        if (!progressiveRequests.has(cachedContextKey)) {
+          progressivePrefixesByContext.delete(cachedContextKey);
+        }
+      }
+    } catch (err) {
+      _iterator4.e(err);
+    } finally {
+      _iterator4.f();
+    }
+    var cachedProgressCount = candidates.filter(function (candidate) {
+      var evidence = getProgressiveEvidence(input.contextKey, candidate.surface, candidate.tokenIds);
+      return evidence !== null && (evidence.scoredTokenCount > 1 || evidence.scoredTokenCount === evidence.totalTokenCount);
+    }).length;
+    if (cachedProgressCount > 0) {
+      logProgressiveState('cached', "ctx=".concat(input.contextKey.slice(0, 40), " \xB7 surfaces=").concat(cachedProgressCount, "/").concat(candidates.length));
+    }
+    if (candidateSignature === previousSignature) {
+      logProgressiveState('deduplicated', "candidate set \xB7 ctx=".concat(input.contextKey.slice(0, 40), " \xB7 surfaces=").concat(candidates.length));
+    } else {
+      logProgressiveState('queued', "candidate set \xB7 ctx=".concat(input.contextKey.slice(0, 40), " \xB7 surfaces=").concat(candidates.length));
+    }
+    _planProgressiveExpansion(input.contextKey);
+  };
 
   // ── Public API (same shape as createSlowLaneClient) ────────────────────
   return {
     updateContext: updateContextDebounced,
+    getBoundaryLmState: function getBoundaryLmState(contextKey) {
+      return getLru(boundaryCache, contextKey);
+    },
+    getCanonicalSurfaceTokenIds: function getCanonicalSurfaceTokenIds(candidateSurface) {
+      return surfaceTokenTrie.getTokenIds(candidateSurface);
+    },
+    getCanonicalSurfaceCount: function getCanonicalSurfaceCount() {
+      return surfaceTokenIds.size;
+    },
+    getContextInput: function getContextInput() {
+      return storedContextInput;
+    },
     getContextVector: function getContextVector() {
       return storedContextVector;
     },
     getLmLogits: function getLmLogits() {
       return storedLmLogits;
     },
+    getProgressiveSurfaceEvidence: function getProgressiveSurfaceEvidence(contextKey, candidateSurface) {
+      return getProgressiveEvidence(contextKey, candidateSurface);
+    },
+    getSurfaceScore: function getSurfaceScore(contextKey, candidateSurface) {
+      return getLru(surfaceScoreCache, surfaceCacheKey(contextKey, candidateSurface));
+    },
     setContextVector: function setContextVector(vector) {
+      storedContextInput = null;
       storedContextVector = vector;
     },
     setLmLogits: function setLmLogits(logits) {
       storedLmLogits = logits;
     },
+    primeBoundaryLm: primeBoundaryLm,
+    requestProgressiveSurfaceScores: requestProgressiveSurfaceScores,
     isWordBoundary: isWordBoundary,
     isReady: function isReady() {
       return ready;
@@ -1182,8 +1913,26 @@ export var createLocalSlowLaneClient = function createLocalSlowLaneClient() {
       activeInferenceText = null;
       activeInferenceRequestId = -1;
       pendingInference = null;
+      storedContextInput = null;
       storedContextVector = null;
       storedLmLogits = null;
+      causalInFlight = false;
+      inFlightBoundaryContextKey = null;
+      kvContextKey = null;
+      kvPath = [];
+      latestCausalFamilyKey = '';
+      pendingBoundaryPrimes.clear();
+      pendingPrefixExpansions.clear();
+      inFlightPrefixExpansions.clear();
+      progressiveRequests.clear();
+      progressivePrefixesByContext.clear();
+      boundaryCache.clear();
+      causalInferenceByContext.clear();
+      causalInferenceByFamily.clear();
+      exactEvidenceCountByContext.clear();
+      prefixExpansionCache.clear();
+      surfaceScoreCache.clear();
+      causalLogitProcessor.resetState();
     }
   };
 };