@atlaskit/editor-plugin-autocomplete 8.0.0 → 9.0.0

package/dist/esm/pm-plugins/text-predictor.js

@@ -1,5 +1,6 @@
-import _typeof from "@babel/runtime/helpers/typeof";
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _typeof from "@babel/runtime/helpers/typeof";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import _createClass from "@babel/runtime/helpers/createClass";
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
@@ -15,7 +16,7 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
  *
  * Two prediction modes:
  *   1. Word boundary → bigram-based next-word suggestion (grammar-filtered)
- *   2. Mid-word (≥3 chars) → trie prefix search → scoring pipeline → top result
+ *   2. Mid-word (≥1 char) → grouped prefetch; ≥3 chars + exact evidence → ghost result
  *
  * Scoring is delegated to scoring-pipeline.ts which handles:
  *   Stage 1 (semantic + frequency), grammar filter, Stage 2 (optional LM re-ranking).
@@ -28,14 +29,12 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
  */
 
 import { EXPERIENCE_NAME, failExp, startExp, succeedExp } from '../analytics/ufo';
-
-// The vocabulary, L3 and word-index payloads are fetched from the CDN in
-// loadDefaultVocabulary / loadVectorsAsync so their (large) contents never enter
-// the editor's bundle and only load when autocomplete is initialised.
-import { ARTIFACT_NAME, fetchArtifactJson, getArtifactUrl } from './artifacts-manifest';
-import { isAutocompleteDebugEnabled } from './debug-mode';
-import { rankCandidates, STAGE1_WEIGHT, STAGE2_WEIGHT, MIN_STAGE1_SCORE } from './scoring-pipeline';
-import { getStoredContextVector, getStoredLmLogits } from './slow-lane-client';
+import { fetchAutocompleteArtifactBinary, fetchAutocompleteArtifactJson } from './artifact-loader';
+import { ARTIFACT_NAME } from './artifacts-manifest';
+import { createCanonicalContextPositionCache, deriveCanonicalCandidateContext, deriveWhitespaceBoundaryContext, logSoftmaxAt, logSumExp, selectBoundaryPrimeRequests } from './canonical-lm-scoring';
+import { CTC_STYLES, ctcSection, ctcTag, isAutocompleteDebugEnabled, isAutocompleteDebugVerbose } from './debug-mode';
+import { loadGrammarDataAsync, rankCandidates, STAGE1_WEIGHT, STAGE2_WEIGHT, MIN_STAGE1_SCORE, MIN_WINNER_MARGIN } from './scoring-pipeline';
+import { getBoundaryLmState, getCanonicalSurfaceCount, getCanonicalSurfaceTokenIds, getDefaultSlowLaneClientStatus, getProgressiveSurfaceEvidence, getStoredContextInput, getStoredContextVector, getStoredLmLogits, getSurfaceScore, isCanonicalSurfaceScoringSupported, primeBoundaryLm, requestProgressiveSurfaceScores } from './slow-lane-client';
 
 // ─── Constants ───────────────────────────────────────────────────────────────
 
@@ -47,13 +46,152 @@ var WHITESPACE_SPLIT_REGEX = /\s+/;
 var SENTENCE_BOUNDARY_REGEX = /[\n.?!]+/;
 // eslint-disable-next-line require-unicode-regexp
 var TRAILING_WHITESPACE_REGEX = /\s$/;
-var MIN_PREFIX_LENGTH = 3;
+var TRAILING_SURFACE_TOKEN_REGEX = /(?:['\x2D0-9A-Z_a-z\xAA\xB2\xB3\xB5\xB9\xBA\xBC-\xBE\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u05D0-\u05EA\u05EF-\u05F2\u0620-\u064A\u0660-\u0669\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07C0-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u0870-\u0887\u0889-\u088F\u08A0-\u08C9\u0904-\u0939\u093D\u0950\u0958-\u0961\u0966-\u096F\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09E6-\u09F1\u09F4-\u09F9\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A66-\u0A6F\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AE6-\u0AEF\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B66-\u0B6F\u0B71-\u0B77\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0BE6-\u0BF2\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C5C\u0C5D\u0C60\u0C61\u0C66-\u0C6F\u0C78-\u0C7E\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDC-\u0CDE\u0CE0\u0CE1\u0CE6-\u0CEF\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D58-\u0D61\u0D66-\u0D78\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DE6-\u0DEF\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F20-\u0F33\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F-\u1049\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u1090-\u1099\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1369-\u137C\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u1711\u171F-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u17E0-\u17E9\u17F0-\u17F9\u1810-\u1819\u1820-\u1878\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u1A00-\u1A16\u1A20-\u1A54\u1A80-\u1A89\u1A90-\u1A99\u1AA7\u1B05-\u1B33\u1B45-\u1B4C\u1B50-\u1B59\u1B83-\u1BA0\u1BAE-\u1BE5\u1C00-\u1C23\u1C40-\u1C49\u1C4D-\u1C7D\u1C80-\u1C8A\u1C90-\u1CBA\u1CBD-\u1CBF\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2070\u2071\u2074-\u2079\u207F-\u2089\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2150-\u2189\u2460-\u249B\u24EA-\u24FF\u2776-\u2793\u2C00-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2CFD\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u3192-\u3195\u31A0-\u31BF\u31F0-\u31FF\u3220-\u3229\u3248-\u324F\u3251-\u325F\u3280-\u3289\u32B1-\u32BF\u3400-\u4DBF\u4E00-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7DC\uA7F1-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA830-\uA835\uA840-\uA873\uA882-\uA8B3\uA8D0-\uA8D9\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA900-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF-\uA9D9\uA9E0-\uA9E4\uA9E6-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA50-\uAA59\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABE2\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD07-\uDD33\uDD40-\uDD78\uDD8A\uDD8B\uDE80-\uDE9C\uDEA0-\uDED0\uDEE1-\uDEFB\uDF00-\uDF23\uDF2D-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDD70-\uDD7A\uDD7C-\uDD8A\uDD8C-\uDD92\uDD94\uDD95\uDD97-\uDDA1\uDDA3-\uDDB1\uDDB3-\uDDB9\uDDBB\uDDBC\uDDC0-\uDDF3\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67\uDF80-\uDF85\uDF87-\uDFB0\uDFB2-\uDFBA]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC58-\uDC76\uDC79-\uDC9E\uDCA7-\uDCAF\uDCE0-\uDCF2\uDCF4\uDCF5\uDCFB-\uDD1B\uDD20-\uDD39\uDD40-\uDD59\uDD80-\uDDB7\uDDBC-\uDDCF\uDDD2-\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE35\uDE40-\uDE48\uDE60-\uDE7E\uDE80-\uDE9F\uDEC0-\uDEC7\uDEC9-\uDEE4\uDEEB-\uDEEF\uDF00-\uDF35\uDF40-\uDF55\uDF58-\uDF72\uDF78-\uDF91\uDFA9-\uDFAF]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2\uDCFA-\uDD23\uDD30-\uDD39\uDD40-\uDD65\uDD6F-\uDD85\uDE60-\uDE7E\uDE80-\uDEA9\uDEB0\uDEB1\uDEC2-\uDEC7\uDF00-\uDF27\uDF30-\uDF45\uDF51-\uDF54\uDF70-\uDF81\uDFB0-\uDFCB\uDFE0-\uDFF6]|\uD804[\uDC03-\uDC37\uDC52-\uDC6F\uDC71\uDC72\uDC75\uDC83-\uDCAF\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD03-\uDD26\uDD36-\uDD3F\uDD44\uDD47\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDD0-\uDDDA\uDDDC\uDDE1-\uDDF4\uDE00-\uDE11\uDE13-\uDE2B\uDE3F\uDE40\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDEF0-\uDEF9\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61\uDF80-\uDF89\uDF8B\uDF8E\uDF90-\uDFB5\uDFB7\uDFD1\uDFD3]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC50-\uDC59\uDC5F-\uDC61\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE50-\uDE59\uDE80-\uDEAA\uDEB8\uDEC0-\uDEC9\uDED0-\uDEE3\uDF00-\uDF1A\uDF30-\uDF3B\uDF40-\uDF46]|\uD806[\uDC00-\uDC2B\uDCA0-\uDCF2\uDCFF-\uDD06\uDD09\uDD0C-\uDD13\uDD15\uDD16\uDD18-\uDD2F\uDD3F\uDD41\uDD50-\uDD59\uDDA0-\uDDA7\uDDAA-\uDDD0\uDDE1\uDDE3\uDE00\uDE0B-\uDE32\uDE3A\uDE50\uDE5C-\uDE89\uDE9D\uDEB0-\uDEF8\uDFC0-\uDFE0\uDFF0-\uDFF9]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC50-\uDC6C\uDC72-\uDC8F\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD30\uDD46\uDD50-\uDD59\uDD60-\uDD65\uDD67\uDD68\uDD6A-\uDD89\uDD98\uDDA0-\uDDA9\uDDB0-\uDDDB\uDDE0-\uDDE9\uDEE0-\uDEF2\uDF02\uDF04-\uDF10\uDF12-\uDF33\uDF50-\uDF59\uDFB0\uDFC0-\uDFD4]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|\uD80B[\uDF90-\uDFF0]|[\uD80C\uD80E\uD80F\uD81C-\uD822\uD840-\uD868\uD86A-\uD86D\uD86F-\uD872\uD874-\uD879\uD880-\uD883\uD885-\uD88C][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2F\uDC41-\uDC46\uDC60-\uDFFF]|\uD810[\uDC00-\uDFFA]|\uD811[\uDC00-\uDE46]|\uD818[\uDD00-\uDD1D\uDD30-\uDD39]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDE70-\uDEBE\uDEC0-\uDEC9\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF50-\uDF59\uDF5B-\uDF61\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDD40-\uDD6C\uDD70-\uDD79\uDE40-\uDE96\uDEA0-\uDEB8\uDEBB-\uDED3\uDF00-\uDF4A\uDF50\uDF93-\uDF9F\uDFE0\uDFE1\uDFE3\uDFF2-\uDFF6]|\uD823[\uDC00-\uDCD5\uDCFF-\uDD1E\uDD80-\uDDF2]|\uD82B[\uDFF0-\uDFF3\uDFF5-\uDFFB\uDFFD\uDFFE]|\uD82C[\uDC00-\uDD22\uDD32\uDD50-\uDD52\uDD55\uDD64-\uDD67\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD833[\uDCF0-\uDCF9]|\uD834[\uDEC0-\uDED3\uDEE0-\uDEF3\uDF60-\uDF78]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD837[\uDF00-\uDF1E\uDF25-\uDF2A]|\uD838[\uDC30-\uDC6D\uDD00-\uDD2C\uDD37-\uDD3D\uDD40-\uDD49\uDD4E\uDE90-\uDEAD\uDEC0-\uDEEB\uDEF0-\uDEF9]|\uD839[\uDCD0-\uDCEB\uDCF0-\uDCF9\uDDD0-\uDDED\uDDF0-\uDDFA\uDEC0-\uDEDE\uDEE0-\uDEE2\uDEE4\uDEE5\uDEE7-\uDEED\uDEF0-\uDEF4\uDEFE\uDEFF\uDFE0-\uDFE6\uDFE8-\uDFEB\uDFED\uDFEE\uDFF0-\uDFFE]|\uD83A[\uDC00-\uDCC4\uDCC7-\uDCCF\uDD00-\uDD43\uDD4B\uDD50-\uDD59]|\uD83B[\uDC71-\uDCAB\uDCAD-\uDCAF\uDCB1-\uDCB4\uDD01-\uDD2D\uDD2F-\uDD3D\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD83C[\uDD00-\uDD0C]|\uD83E[\uDFF0-\uDFF9]|\uD869[\uDC00-\uDEDF\uDF00-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEAD\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0\uDFF0-\uDFFF]|\uD87B[\uDC00-\uDE5D]|\uD87E[\uDC00-\uDE1D]|\uD884[\uDC00-\uDF4A\uDF50-\uDFFF]|\uD88D[\uDC00-\uDC79])+$/;
+var SURFACE_TOKEN_REGEX = /(?:['\x2D0-9A-Z_a-z\xAA\xB2\xB3\xB5\xB9\xBA\xBC-\xBE\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u05D0-\u05EA\u05EF-\u05F2\u0620-\u064A\u0660-\u0669\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07C0-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u0870-\u0887\u0889-\u088F\u08A0-\u08C9\u0904-\u0939\u093D\u0950\u0958-\u0961\u0966-\u096F\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09E6-\u09F1\u09F4-\u09F9\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A66-\u0A6F\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AE6-\u0AEF\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B66-\u0B6F\u0B71-\u0B77\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0BE6-\u0BF2\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C5C\u0C5D\u0C60\u0C61\u0C66-\u0C6F\u0C78-\u0C7E\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDC-\u0CDE\u0CE0\u0CE1\u0CE6-\u0CEF\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D58-\u0D61\u0D66-\u0D78\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DE6-\u0DEF\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F20-\u0F33\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F-\u1049\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u1090-\u1099\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1369-\u137C\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u1711\u171F-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u17E0-\u17E9\u17F0-\u17F9\u1810-\u1819\u1820-\u1878\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u1A00-\u1A16\u1A20-\u1A54\u1A80-\u1A89\u1A90-\u1A99\u1AA7\u1B05-\u1B33\u1B45-\u1B4C\u1B50-\u1B59\u1B83-\u1BA0\u1BAE-\u1BE5\u1C00-\u1C23\u1C40-\u1C49\u1C4D-\u1C7D\u1C80-\u1C8A\u1C90-\u1CBA\u1CBD-\u1CBF\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2070\u2071\u2074-\u2079\u207F-\u2089\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2150-\u2189\u2460-\u249B\u24EA-\u24FF\u2776-\u2793\u2C00-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2CFD\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u3192-\u3195\u31A0-\u31BF\u31F0-\u31FF\u3220-\u3229\u3248-\u324F\u3251-\u325F\u3280-\u3289\u32B1-\u32BF\u3400-\u4DBF\u4E00-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7DC\uA7F1-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA830-\uA835\uA840-\uA873\uA882-\uA8B3\uA8D0-\uA8D9\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA900-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF-\uA9D9\uA9E0-\uA9E4\uA9E6-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA50-\uAA59\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABE2\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD07-\uDD33\uDD40-\uDD78\uDD8A\uDD8B\uDE80-\uDE9C\uDEA0-\uDED0\uDEE1-\uDEFB\uDF00-\uDF23\uDF2D-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDD70-\uDD7A\uDD7C-\uDD8A\uDD8C-\uDD92\uDD94\uDD95\uDD97-\uDDA1\uDDA3-\uDDB1\uDDB3-\uDDB9\uDDBB\uDDBC\uDDC0-\uDDF3\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67\uDF80-\uDF85\uDF87-\uDFB0\uDFB2-\uDFBA]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC58-\uDC76\uDC79-\uDC9E\uDCA7-\uDCAF\uDCE0-\uDCF2\uDCF4\uDCF5\uDCFB-\uDD1B\uDD20-\uDD39\uDD40-\uDD59\uDD80-\uDDB7\uDDBC-\uDDCF\uDDD2-\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE35\uDE40-\uDE48\uDE60-\uDE7E\uDE80-\uDE9F\uDEC0-\uDEC7\uDEC9-\uDEE4\uDEEB-\uDEEF\uDF00-\uDF35\uDF40-\uDF55\uDF58-\uDF72\uDF78-\uDF91\uDFA9-\uDFAF]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2\uDCFA-\uDD23\uDD30-\uDD39\uDD40-\uDD65\uDD6F-\uDD85\uDE60-\uDE7E\uDE80-\uDEA9\uDEB0\uDEB1\uDEC2-\uDEC7\uDF00-\uDF27\uDF30-\uDF45\uDF51-\uDF54\uDF70-\uDF81\uDFB0-\uDFCB\uDFE0-\uDFF6]|\uD804[\uDC03-\uDC37\uDC52-\uDC6F\uDC71\uDC72\uDC75\uDC83-\uDCAF\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD03-\uDD26\uDD36-\uDD3F\uDD44\uDD47\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDD0-\uDDDA\uDDDC\uDDE1-\uDDF4\uDE00-\uDE11\uDE13-\uDE2B\uDE3F\uDE40\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDEF0-\uDEF9\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61\uDF80-\uDF89\uDF8B\uDF8E\uDF90-\uDFB5\uDFB7\uDFD1\uDFD3]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC50-\uDC59\uDC5F-\uDC61\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE50-\uDE59\uDE80-\uDEAA\uDEB8\uDEC0-\uDEC9\uDED0-\uDEE3\uDF00-\uDF1A\uDF30-\uDF3B\uDF40-\uDF46]|\uD806[\uDC00-\uDC2B\uDCA0-\uDCF2\uDCFF-\uDD06\uDD09\uDD0C-\uDD13\uDD15\uDD16\uDD18-\uDD2F\uDD3F\uDD41\uDD50-\uDD59\uDDA0-\uDDA7\uDDAA-\uDDD0\uDDE1\uDDE3\uDE00\uDE0B-\uDE32\uDE3A\uDE50\uDE5C-\uDE89\uDE9D\uDEB0-\uDEF8\uDFC0-\uDFE0\uDFF0-\uDFF9]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC50-\uDC6C\uDC72-\uDC8F\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD30\uDD46\uDD50-\uDD59\uDD60-\uDD65\uDD67\uDD68\uDD6A-\uDD89\uDD98\uDDA0-\uDDA9\uDDB0-\uDDDB\uDDE0-\uDDE9\uDEE0-\uDEF2\uDF02\uDF04-\uDF10\uDF12-\uDF33\uDF50-\uDF59\uDFB0\uDFC0-\uDFD4]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|\uD80B[\uDF90-\uDFF0]|[\uD80C\uD80E\uD80F\uD81C-\uD822\uD840-\uD868\uD86A-\uD86D\uD86F-\uD872\uD874-\uD879\uD880-\uD883\uD885-\uD88C][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2F\uDC41-\uDC46\uDC60-\uDFFF]|\uD810[\uDC00-\uDFFA]|\uD811[\uDC00-\uDE46]|\uD818[\uDD00-\uDD1D\uDD30-\uDD39]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDE70-\uDEBE\uDEC0-\uDEC9\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF50-\uDF59\uDF5B-\uDF61\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDD40-\uDD6C\uDD70-\uDD79\uDE40-\uDE96\uDEA0-\uDEB8\uDEBB-\uDED3\uDF00-\uDF4A\uDF50\uDF93-\uDF9F\uDFE0\uDFE1\uDFE3\uDFF2-\uDFF6]|\uD823[\uDC00-\uDCD5\uDCFF-\uDD1E\uDD80-\uDDF2]|\uD82B[\uDFF0-\uDFF3\uDFF5-\uDFFB\uDFFD\uDFFE]|\uD82C[\uDC00-\uDD22\uDD32\uDD50-\uDD52\uDD55\uDD64-\uDD67\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD833[\uDCF0-\uDCF9]|\uD834[\uDEC0-\uDED3\uDEE0-\uDEF3\uDF60-\uDF78]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD837[\uDF00-\uDF1E\uDF25-\uDF2A]|\uD838[\uDC30-\uDC6D\uDD00-\uDD2C\uDD37-\uDD3D\uDD40-\uDD49\uDD4E\uDE90-\uDEAD\uDEC0-\uDEEB\uDEF0-\uDEF9]|\uD839[\uDCD0-\uDCEB\uDCF0-\uDCF9\uDDD0-\uDDED\uDDF0-\uDDFA\uDEC0-\uDEDE\uDEE0-\uDEE2\uDEE4\uDEE5\uDEE7-\uDEED\uDEF0-\uDEF4\uDEFE\uDEFF\uDFE0-\uDFE6\uDFE8-\uDFEB\uDFED\uDFEE\uDFF0-\uDFFE]|\uD83A[\uDC00-\uDCC4\uDCC7-\uDCCF\uDD00-\uDD43\uDD4B\uDD50-\uDD59]|\uD83B[\uDC71-\uDCAB\uDCAD-\uDCAF\uDCB1-\uDCB4\uDD01-\uDD2D\uDD2F-\uDD3D\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD83C[\uDD00-\uDD0C]|\uD83E[\uDFF0-\uDFF9]|\uD869[\uDC00-\uDEDF\uDF00-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEAD\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0\uDFF0-\uDFFF]|\uD87B[\uDC00-\uDE5D]|\uD87E[\uDC00-\uDE1D]|\uD884[\uDC00-\uDF4A\uDF50-\uDFFF]|\uD88D[\uDC00-\uDC79])+/g;
+var ONLY_WHITESPACE_REGEX = /^[\t-\r \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]+$/;
+var UNIGRAM_PREFETCH_MIN_PREFIX_LENGTH = 1;
+var MULTIWORD_PREFETCH_MIN_PREFIX_LENGTH = 1;
+var DISPLAY_MIN_PREFIX_LENGTH = 3;
 var MAX_CANDIDATES = 200;
 var CONTEXT_WORDS = 10;
-var MIN_SCORE_THRESHOLD = 0.35;
 var L3_BASELINE_FREQ = 0.001;
+// Max tokens in a completion term (bigram=2, phrase=3). Mirrors the producer's
+// `phrase_max_words` default so the FE window never exceeds what was mined.
+var PHRASE_MAX_WORDS = 3;
+// Per-window cap on phrase-trie subtree collection (keeps the hot path bounded).
+var MAX_PHRASE_CANDIDATES = 50;
+/**
+ * Share of its context shortlist's probability mass the model must put on a
+ * surface before that surface may be shown.
+ *
+ * Candidates competing at the same boundary are normalised into a posterior
+ * over that shortlist, so this reads directly as "the model is at least this
+ * sure". Measuring distance from the best candidate instead cannot express
+ * being unsure: the leader scores full marks whether it won by a nose or a
+ * mile, which pushes the entire question of how contested a context is onto
+ * `MIN_WINNER_MARGIN` — and there the blended score's only remaining spread is
+ * the corpus prior, the weakest ranking signal we have.
+ *
+ * Each extra token raises the bar. A wrong multi-word ghost costs the reader
+ * more to notice and undo than a wrong single word, and it is offered from the
+ * same keystroke, so precision has to be bought per token of commitment.
+ */
+var MIN_LM_POSTERIOR = {
+  word: 0.5,
+  bigram: 0.6,
+  phrase: 0.7
+};
+/**
+ * How many scored candidates a context must hold before its leader may show.
+ *
+ * A posterior is a share of a shortlist, so a shortlist of one hands its only
+ * member 1.0 whatever the model thinks of it — `logSumExp` of a single value
+ * returns that value. Such a ghost sits in the top bucket without having beaten
+ * anything, and it is the gate's blind spot rather than a case the gate ruled
+ * on: 1 in 14 of them were accepted against 34% for word ghosts overall, and
+ * every phrase shown through this hole was rejected.
+ *
+ * Counted over pool membership rather than over the normaliser, because those
+ * two deliberately differ. Where a pool holds a surface and its own extension
+ * the chain rule leaves one term in the denominator, and the resulting 1.0 is
+ * earned — whichever the user meant, the shorter form is a correct ghost.
+ *
+ * Waived where the context never held a second candidate at all. The 1-in-14
+ * acceptance above was measured over a population dominated by pools that read
+ * as one because rivals had not come back, and it is that absence of evidence
+ * the floor is for. A vocabulary offering a single continuation of a long
+ * distinctive prefix is the opposite situation, and it is also where a ghost
+ * saves the most keystrokes, so refusing it spends the most to learn the least.
+ */
+var MIN_SCORED_POOL_SIZE = 2;
+/**
+ * Mean per-token log-probability a surface must hold, in nats, independently of
+ * anything it was competing against.
+ *
+ * Every other display test is relative: a posterior is a share of a shortlist,
+ * and a winner margin is a distance from a rival. So a surface reaches the
+ * screen by being the best of what happened to be in its pool, and nothing ever
+ * asks whether the model finds it plausible at all. That gap was tolerable while
+ * little was being read, and stopped being tolerable once the scheduler started
+ * reading roughly twice as much per decision: shown-per-decision went from 3.2%
+ * to 7.4% with no threshold moved, and acceptance of what showed fell from 32%
+ * to 24.5%. More reading does not weaken a relative test — it hands it far more
+ * pools to be the winner of, and the marginal winner is worse than the average.
+ *
+ * Set at the point where a uniform distribution over the model's vocabulary
+ * sits: 49,152 tokens, so `ln(1/49152)` is about -10.8 nats. Below it the model
+ * assigns the surface less mass than a token drawn at random, which is the only
+ * statement about a surface that needs no reference to what it competed with.
+ *
+ * It was first tried at -8, chosen from the bucket where acceptance was measured
+ * to fall away, and that reasoning does not survive more data. Acceptance against
+ * this quantity turned out to be a smooth slope — about 19% below -8, 26% from -8
+ * to -6, then flat near 35% above - with no discontinuity to place a threshold
+ * at. A floor on a smooth slope is a coverage dial rather than a test: -8 removed
+ * a band converting at 26% and cost 3.7 points of show rate, for an acceptance
+ * movement no sample of this size can resolve. Anchoring to uniform instead makes
+ * the value an argument about what is indefensible rather than a point picked off
+ * a histogram, which is what stops it from being retuned every batch.
+ *
+ * Applied to the mean over the verified prefix, the same quantity
+ * `ghostsByMeanLogProb` buckets, and deliberately not to
+ * `meanTokenLogProbabilityUpperBound`. The bound is the right instrument for
+ * keeping a candidate in the race, where dropping something that could still
+ * clear the bar would be an error, but it is systematically higher than the
+ * quantity acceptance is measured against. Judging a surface on the prefix that
+ * was actually read is also what every other test here does.
+ *
+ * One value across all three shapes. Splitting it per shape needs an acceptance
+ * curve per shape, and 19 bigrams and 1 phrase across five sessions cannot
+ * support one.
+ */
+var MIN_MEAN_TOKEN_LOG_PROBABILITY = -10.8;
+// Tab replaces the whole remaining suffix, so an N-character completion saves
+// N-1 keystrokes: at one character it saves nothing at all and at two it saves
+// one, which does not repay noticing the ghost and reaching for Tab. Offering
+// them anyway spends the acceptance-rate denominator on completions nobody
+// wants and teaches the user to stop reading ghosts. `DISPLAY_MIN_PREFIX_LENGTH`
+// is the same guard on the side the user has already typed.
+var MIN_SUGGESTION_LENGTH = 3;
+/**
+ * How many leading tokens of a surface must be scored before it may be shown.
+ *
+ * Scoring a token costs one model round trip, and a round trip costs about the
+ * same no matter how much is in it, so the price of a candidate is its token
+ * count. Demanding every token therefore caps what can ever reach the screen at
+ * roughly two tokens inside the decision budget — which is why no phrase has
+ * ever been displayed. Verifying a fixed prefix makes the cost of a candidate
+ * independent of its length.
+ */
+var REQUIRED_VERIFIED_TOKENS = 2;
+/**
+ * Extra winner margin demanded of a surface judged on a verified prefix rather
+ * than on every one of its tokens, to buy back the precision given up by
+ * leaving the tail unread.
+ */
+var PARTIAL_EVIDENCE_MARGIN_PREMIUM = 0.08;
+var ARBITRATION_MODE = 'confidence-v2';
+var DEBUG_TEXT_TAIL_CHARS = 120;
 
 // ─── Types ───────────────────────────────────────────────────────────────────
+
+/**
+ * Which constraint stopped an evaluation from putting a ghost on screen.
+ *
+ * Each one implies different work: `below-posterior-gate` is a threshold to
+ * calibrate, `winner-margin` is two candidates the model cannot separate,
+ * `cold-competitor` and `unresolved-rival` are scheduling, and `no-candidate`
+ * is vocabulary coverage.
+ */
+
+/**
+ * A candidate paired with the length of the already-typed prefix it completes.
+ * For a single word this is the current partial token length; for a phrase it
+ * is the length of the matched multi-word window (previous words + partial),
+ * so the ghost tail is `word.slice(matchedPrefixLen)`.
+ */
+
+/** Optional per-term metadata carried by bigram/phrase completion terms. */
 var TrieNode = /*#__PURE__*/_createClass(function TrieNode() {
   _classCallCheck(this, TrieNode);
   _defineProperty(this, "children", new Map());
@@ -62,6 +200,12 @@ var TrieNode = /*#__PURE__*/_createClass(function TrieNode() {
   _defineProperty(this, "docFreq", 0);
   _defineProperty(this, "authorFreq", 0);
   _defineProperty(this, "sessionFreq", 0);
+  // Term-type + phrase metadata. Plain words keep `termType='word'` and null
+  // metadata; bigram/phrase nodes carry the producer-shipped POS + association.
+  _defineProperty(this, "termType", 'word');
+  _defineProperty(this, "posSeq", null);
+  _defineProperty(this, "headPos", null);
+  _defineProperty(this, "association", null);
 });
 var WeightedWordTrie = /*#__PURE__*/function () {
   function WeightedWordTrie() {
@@ -72,7 +216,8 @@ var WeightedWordTrie = /*#__PURE__*/function () {
   }
   return _createClass(WeightedWordTrie, [{
     key: "insert",
-    value: function insert(word, tenantFreq, docFreq, authorFreq) {
+    value: function insert(word, tenantFreq, docFreq, authorFreq, meta) {
+      var _meta$termType, _meta$posSeq, _meta$headPos, _meta$association;
       var node = this.root;
       var _iterator = _createForOfIteratorHelper(word.toLowerCase()),
         _step;
@@ -95,6 +240,10 @@ var WeightedWordTrie = /*#__PURE__*/function () {
       node.tenantFreq = tenantFreq;
       node.docFreq = docFreq;
       node.authorFreq = authorFreq;
+      node.termType = (_meta$termType = meta === null || meta === void 0 ? void 0 : meta.termType) !== null && _meta$termType !== void 0 ? _meta$termType : 'word';
+      node.posSeq = (_meta$posSeq = meta === null || meta === void 0 ? void 0 : meta.posSeq) !== null && _meta$posSeq !== void 0 ? _meta$posSeq : null;
+      node.headPos = (_meta$headPos = meta === null || meta === void 0 ? void 0 : meta.headPos) !== null && _meta$headPos !== void 0 ? _meta$headPos : null;
+      node.association = (_meta$association = meta === null || meta === void 0 ? void 0 : meta.association) !== null && _meta$association !== void 0 ? _meta$association : null;
       if (tenantFreq > this.maxTenantFreq) {
         this.maxTenantFreq = tenantFreq;
       }
@@ -214,6 +363,15 @@ var wordTrie = new WeightedWordTrie();
 // L3 Trie (General English Fallback)
 var l3Trie = new WeightedWordTrie();
 
+/**
+ * L2 phrase/bigram trie. Kept SEPARATE from `wordTrie` so single-word
+ * completion + L3 gap-fill stay untouched; multi-word units are only surfaced
+ * by the (12b) multiword prefix-window matcher. Keys are the full normalized
+ * surface string (spaces included), e.g. `"return on investment"`, so a lookup
+ * is a plain char-trie walk over the whole phrase.
+ */
+var phraseTrie = new WeightedWordTrie();
+
 /**
  * Loads the General English vocabulary.
  * expects a simple array of strings: ["about", "above", "actually", ...]
@@ -233,10 +391,8 @@ export var initL3Vocabulary = function initL3Vocabulary(l3Words) {
   } finally {
     _iterator5.f();
   }
-  if (isAutocompleteDebugEnabled()) {
-    // eslint-disable-next-line no-console
-    console.log("[text-predictor] L3 General English loaded: ".concat(l3Words.length, " words"));
-  }
+  recallGeneration++;
+  ctcTag('init', "L3 general English loaded: ".concat(l3Words.length, " words"));
 };
 
 // const bigramMap: Map<string, Record<string, number>> = new Map(
@@ -246,8 +402,50 @@ export var initL3Vocabulary = function initL3Vocabulary(l3Words) {
 var isInitialized = false;
 var vectorStore = null;
 var vectorsLoadStarted = false;
+
+// Phrase/bigram artifacts load independently of the word vocabulary so a
+// missing/late `bigrams.json`/`phrases.json` never breaks word completion.
+var phrasesLoadStarted = false;
+var phrasesLoaded = false;
+var phraseTermCount = 0;
+// Per-type frequency maxima, tracked separately because bigrams and phrases
+// share one trie but have very different absolute frequency ranges (bigrams are
+// far more frequent than 3-word phrases). Normalizing each type by its OWN max
+// stops phrase freq scores from being crushed against the top bigram's count.
+var maxBigramFreq = 1;
+var maxPhraseFreq = 1;
 var lastPredictionDebug = null;
 
+// ── Stabilization (QI-2): post-accept cooldown + whole-surface repetition ────
+// Two guards that stop the accept→echo (`end to end` → `end to end to end`) and
+// generally keep a just-accepted unit from being re-offered:
+//  • repetition: never surface a candidate whose full surface already equals the
+//    run of tokens immediately before the cursor (handled inline in predict()).
+//  • cooldown: after an accept, briefly suppress re-offering that same unit. The
+//    cooldown lifts only once BOTH the keystroke budget and the time window have
+//    elapsed (either one still counting keeps it active).
+var COOLDOWN_KEYSTROKES = 5;
+var COOLDOWN_MS = 2000;
+
+// Active post-accept cooldown, or null when none.
+var acceptCooldown = null;
+
+/**
+ * Start a short cooldown for the exact surface the editor inserted. The caller
+ * passes the committed snapshot's surface so background re-ranking can never
+ * move cooldown bookkeeping away from what the user actually accepted.
+ */
+export var noteSuggestionAccepted = function noteSuggestionAccepted(surface) {
+  var normalizedSurface = surface.trim().toLowerCase();
+  if (normalizedSurface) {
+    acceptCooldown = {
+      predictionsSince: 0,
+      surface: normalizedSurface,
+      ts: performance.now()
+    };
+  }
+};
+
 /** Get vector for a word from the store. */
 var getWordVector = function getWordVector(word) {
   if (!vectorStore) {
@@ -344,6 +542,124 @@ var extractPreviousWord = function extractPreviousWord(text) {
   return words.length >= 2 ? words[words.length - 2] : '';
 };
 
+/**
+ * Collect phrase/bigram completion candidates for the multi-word window ending
+ * at the current partial token.
+ *
+ * Builds windows of the last `2..PHRASE_MAX_WORDS` tokens of the current
+ * sentence (widest first) and prefix-searches the phrase trie for each, so
+ * `quarterly pla` matches `quarterly planning meeting`. Windows never cross a
+ * sentence boundary (mirrors `extractPreviousWord`). Each result records the
+ * matched window length so the caller can compute the ghost tail.
+ *
+ * :params:
+ *   trimmed: Text before the cursor, trailing whitespace already removed
+ * :returns:
+ *   Matched phrase candidates (deduped, widest-window match wins per term)
+ */
+var getPhraseCandidates = function getPhraseCandidates(trimmed) {
+  // Records every prefix window we probe and its match count so the (verbose)
+  // debug line makes it obvious whether the phrase path found nothing because the
+  // trie is empty, or because no phrase begins with the typed window.
+  var windowsTried = [];
+  var logPhrasePath = function logPhrasePath(skipReason) {
+    if (!isAutocompleteDebugVerbose()) {
+      return;
+    }
+    var detail = skipReason ? skipReason : "windows: ".concat(windowsTried.map(function (w) {
+      return "\"".concat(w.window, "\"\u2192").concat(w.matches);
+    }).join(', ') || '(none)');
+    ctcTag('phrase', "loaded=".concat(phraseTermCount, " (").concat(phrasesLoaded ? 'ready' : 'not loaded', ") \xB7 ").concat(detail), CTC_STYLES.section);
+  };
+  if (phraseTermCount === 0) {
+    logPhrasePath('phrase trie empty — bigrams.json/phrases.json not loaded (or 0 terms)');
+    return [];
+  }
+  var tokenMatches = Array.from(trimmed.matchAll(SURFACE_TOKEN_REGEX));
+  var lastMatch = tokenMatches[tokenMatches.length - 1];
+  var lastStart = lastMatch === null || lastMatch === void 0 ? void 0 : lastMatch.index;
+  if (!lastMatch || lastStart === undefined || lastStart + lastMatch[0].length !== trimmed.length) {
+    logPhrasePath('no tokens in current sentence');
+    return [];
+  }
+  var trailingTokens = [{
+    start: lastStart,
+    value: lastMatch[0]
+  }];
+  for (var i = tokenMatches.length - 2; i >= 0; i--) {
+    var current = trailingTokens[0];
+    var match = tokenMatches[i];
+    var start = match.index;
+    if (start === undefined) {
+      break;
+    }
+    var end = start + match[0].length;
+    var gap = trimmed.slice(end, current.start);
+    if (!ONLY_WHITESPACE_REGEX.test(gap)) {
+      break;
+    }
+    trailingTokens.unshift({
+      start: start,
+      value: match[0]
+    });
+    if (trailingTokens.length >= PHRASE_MAX_WORDS) {
+      break;
+    }
+  }
+  var partial = trailingTokens[trailingTokens.length - 1].value;
+  var results = [];
+  var seen = new Set();
+  var maxPrev = trailingTokens.length - 1;
+
+  // Widest window first so the most specific (longest-context) match wins the
+  // dedup for a given phrase term. `prev` is the number of *preceding* complete
+  // words included ahead of the current partial:
+  //   prev ≥ 1 → "continue a phrase I've started" (e.g. "root c" → root cause).
+  //              Preceding-word context is strong, so a short partial is fine.
+  //   prev = 0 → "the partial is a phrase's FIRST word" (e.g. "root" → root
+  //              cause). No preceding context, so require the partial to be a
+  //              one character so grouped LM work can begin early. UI remains
+  //              gated at DISPLAY_MIN_PREFIX_LENGTH.
+  for (var prev = maxPrev; prev >= 0; prev--) {
+    if (prev === 0 && partial.length < MULTIWORD_PREFETCH_MIN_PREFIX_LENGTH) {
+      continue;
+    }
+    var windowTokens = trailingTokens.slice(-(prev + 1));
+    var windowPrefix = windowTokens.map(function (token) {
+      return token.value;
+    }).join(' ').toLowerCase();
+    var windowLen = windowPrefix.length;
+    var matches = phraseTrie.getCandidates(windowPrefix, MAX_PHRASE_CANDIDATES);
+    windowsTried.push({
+      window: windowPrefix,
+      matches: matches.length
+    });
+    var _iterator8 = _createForOfIteratorHelper(matches),
+      _step8;
+    try {
+      for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+        var _match = _step8.value;
+        if (seen.has(_match.word)) {
+          continue;
+        }
+        seen.add(_match.word);
+        results.push({
+          node: _match.node,
+          word: _match.word,
+          matchedPrefixLen: windowLen,
+          surfaceStart: windowTokens[0].start
+        });
+      }
+    } catch (err) {
+      _iterator8.e(err);
+    } finally {
+      _iterator8.f();
+    }
+  }
+  logPhrasePath();
+  return results;
+};
+
 // ─── Debug Helpers ───────────────────────────────────────────────────────────
 
 /**
@@ -352,11 +668,25 @@ var extractPreviousWord = function extractPreviousWord(text) {
  * wordCount: number of words in vector store (0 if not loaded)
  */
 export var getPredictorStatus = function getPredictorStatus() {
+  var slowLaneStatus = getDefaultSlowLaneClientStatus();
   return {
+    canonicalScoringSupported: slowLaneStatus.canonicalScoringSupported,
+    canonicalSurfaceCount: slowLaneStatus.canonicalSurfaceCount,
+    clientId: slowLaneStatus.clientId,
+    clientKind: slowLaneStatus.clientKind,
+    localModelReady: slowLaneStatus.localModelReady,
+    slowLaneRegistered: slowLaneStatus.registered,
     vectorsLoaded: vectorStore !== null,
     wordCount: vectorStore ? Object.keys(vectorStore.wordIndex).length : 0,
     vectorsLoadStarted: vectorsLoadStarted,
-    isInitialized: isInitialized
+    isInitialized: isInitialized,
+    phrasesLoaded: phrasesLoaded,
+    phraseCount: phraseTermCount,
+    maxFreqByType: {
+      word: wordTrie.maxTenantFreq,
+      bigram: maxBigramFreq,
+      phrase: maxPhraseFreq
+    }
   };
 };
 
@@ -368,19 +698,57 @@ export var getLastPredictionDebug = function getLastPredictionDebug() {
   return lastPredictionDebug;
 };
 export var initVocabulary = function initVocabulary(vocabulary) {
-  var _iterator8 = _createForOfIteratorHelper(vocabulary.terms),
-    _step8;
+  var _iterator9 = _createForOfIteratorHelper(vocabulary.terms),
+    _step9;
   try {
-    for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
-      var term = _step8.value;
+    for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+      var term = _step9.value;
       wordTrie.insert(term.word, term.freq, term.docFreq, term.authorFreq);
     }
   } catch (err) {
-    _iterator8.e(err);
+    _iterator9.e(err);
   } finally {
-    _iterator8.f();
+    _iterator9.f();
   }
   isInitialized = true;
+  recallGeneration++;
+};
+
+/**
+ * Insert a producer-shipped bigram/phrase artifact into the phrase trie.
+ *
+ * :params:
+ *   artifact: Normalized `{term: {freq, doc_freq, author_freq, pos_seq, head_pos, association}}` map
+ *   termType: Whether these terms are `bigram` (2 tokens) or `phrase` (3 tokens)
+ * :returns:
+ *   The number of terms inserted
+ */
+export var initPhrases = function initPhrases(artifact, termType) {
+  var count = 0;
+  for (var _i3 = 0, _Object$entries = Object.entries(artifact); _i3 < _Object$entries.length; _i3++) {
+    var _stats$pos_seq, _stats$head_pos, _stats$association;
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i3], 2),
+      term = _Object$entries$_i[0],
+      stats = _Object$entries$_i[1];
+    phraseTrie.insert(term, stats.freq, stats.doc_freq, stats.author_freq, {
+      termType: termType,
+      posSeq: (_stats$pos_seq = stats.pos_seq) !== null && _stats$pos_seq !== void 0 ? _stats$pos_seq : null,
+      headPos: (_stats$head_pos = stats.head_pos) !== null && _stats$head_pos !== void 0 ? _stats$head_pos : null,
+      association: (_stats$association = stats.association) !== null && _stats$association !== void 0 ? _stats$association : null
+    });
+    // Track each type's own frequency ceiling for per-type normalization.
+    if (termType === 'bigram') {
+      if (stats.freq > maxBigramFreq) {
+        maxBigramFreq = stats.freq;
+      }
+    } else if (stats.freq > maxPhraseFreq) {
+      maxPhraseFreq = stats.freq;
+    }
+    count++;
+  }
+  phraseTermCount += count;
+  recallGeneration++;
+  return count;
 };
 
 /**
@@ -407,177 +775,1104 @@ export var ingestDocumentPage = function ingestDocumentPage(pageContent) {
   }
   var words = tokenize(pageContent);
   var validBoostedWords = new Set();
-  var _iterator9 = _createForOfIteratorHelper(words),
-    _step9;
+  var _iterator0 = _createForOfIteratorHelper(words),
+    _step0;
   try {
-    for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
-      var word = _step9.value;
+    for (_iterator0.s(); !(_step0 = _iterator0.n()).done;) {
+      var word = _step0.value;
       var didBoost = wordTrie.incrementSessionFreq(word);
       if (didBoost) {
         validBoostedWords.add(word);
       }
     }
   } catch (err) {
-    _iterator9.e(err);
+    _iterator0.e(err);
   } finally {
-    _iterator9.f();
+    _iterator0.f();
   }
   if (isAutocompleteDebugEnabled() && validBoostedWords.size > 0) {
-    // eslint-disable-next-line no-console
-    console.groupCollapsed("%c[L1 Session] %cPrimed ".concat(validBoostedWords.size, " valid dictionary words from page"), 'color: #00b8d9; font-weight: bold;', 'color: inherit; font-style: italic;');
-    // eslint-disable-next-line no-console
-    console.dir(Array.from(validBoostedWords).sort());
-    // eslint-disable-next-line no-console
-    console.groupEnd();
+    ctcTag('init', "L1 session primed ".concat(validBoostedWords.size, " words from page"), CTC_STYLES.brand);
+    if (isAutocompleteDebugVerbose()) {
+      // eslint-disable-next-line no-console
+      console.dir(Array.from(validBoostedWords).sort());
+    }
   }
 };
-export var predict = function predict(textBefore) {
-  if (!isInitialized) {
-    // Vocabulary JSON is code-split and loads asynchronously. Kick off the load
-    // and skip this keystroke; the plugin also primes it on focus, so the tries
-    // are usually ready before the user types.
-    void loadDefaultVocabulary().catch(function () {});
-    return null;
-  }
-  var t0 = performance.now();
 
-  // ── Step 1: Bigram-based next-word suggestion at word boundary ───────────
-  // if (textBefore.length > 0 && /\s$/u.test(textBefore)) {
-  // 	const words = textBefore.toLowerCase().trimEnd().split(/\s+/u);
-  // 	const prevWord = words[words.length - 1];
-  // 	const nextWords = bigramMap.get(prevWord);
-  // 	if (nextWords) {
-  // 		const sorted = Object.entries(nextWords).sort((a, b) => b[1] - a[1]);
-  // 		let bestWord = '';
-  // 		for (const [word] of sorted) {
-  // 			if (!isGrammarAllowed(prevWord, word)) {
-  // 				continue;
-  // 			}
-  // 			bestWord = word;
-  // 			break;
-  // 		}
-  // 		if (bestWord) {
-  // 			if (debugMode) {
-  // 				const latencyMs = performance.now() - t0;
-  // 				console.log(
-  // 					'%c[autocomplete] BIGRAM',
-  // 					'color:cyan',
-  // 					'| "' + prevWord + '" -> "' + bestWord + '" | ' + latencyMs.toFixed(1) + 'ms',
-  // 				);
-  // 			}
-  // 			return bestWord;
-  // 		}
-  // 	}
-  // 	if (debugMode) {
-  // 		console.log(
-  // 			'%c[autocomplete] BIGRAM-MISS',
-  // 			'color:gray',
-  // 			'| no bigram for "' + words[words.length - 1] + '", skipping prefix completion',
-  // 		);
-  // 	}
-  // 	return null;
-  // }
-
-  // ── Step 2: Prefix completion (≥3 chars typed) ──────────────────────────
-  if (textBefore.length > 0 && TRAILING_WHITESPACE_REGEX.test(textBefore)) {
-    return null;
-  }
-  var trimmed = textBefore.trimEnd();
-  var lastSpaceIdx = trimmed.lastIndexOf(' ');
-  var currentWord = lastSpaceIdx === -1 ? trimmed : trimmed.slice(lastSpaceIdx + 1);
-  if (currentWord.length < MIN_PREFIX_LENGTH) {
-    return null;
-  }
-  var candidates = wordTrie.getCandidates(currentWord, MAX_CANDIDATES);
+/**
+ * Result of a prediction: the ghost tail to insert plus an immutable record of
+ * the evidence that authorized the UI commitment.
+ */
+
+// ─── Recall memo ─────────────────────────────────────────────────────────────
+
+/** Trie recall plus the canonical context derived for each matched term. */
+
+/**
+ * Bumped whenever an artifact load changes what the tries can return, which is
+ * the only way the candidate *set* for a given prefix can change.
+ *
+ * Session-frequency boosts are deliberately not counted: they mutate trie nodes
+ * in place, and the memo holds those nodes by reference, so a boost is already
+ * visible through a cached entry.
+ */
+var recallGeneration = 0;
+var recallMemo = null;
+var computeCanonicalRecall = function computeCanonicalRecall(trimmed, currentWord, currentWordStart) {
+  // Start recall at one character so grouped causal work can overlap later
+  // keystrokes. Nothing is displayed until three characters.
+  var wordCandidates = currentWord.length >= UNIGRAM_PREFETCH_MIN_PREFIX_LENGTH ? wordTrie.getCandidates(currentWord, MAX_CANDIDATES) : [];
 
   // Gap-fill from the L3 general-English trie, requesting a full buffer so
   // enough survive de-duplication against the L2 results.
-  if (candidates.length < MAX_CANDIDATES) {
+  if (currentWord.length >= UNIGRAM_PREFETCH_MIN_PREFIX_LENGTH && wordCandidates.length < MAX_CANDIDATES) {
     var l3Candidates = l3Trie.getCandidates(currentWord, MAX_CANDIDATES);
-    var existingWords = new Set(candidates.map(function (c) {
+    var existingWords = new Set(wordCandidates.map(function (c) {
       return c.word;
     }));
-    var _iterator0 = _createForOfIteratorHelper(l3Candidates),
-      _step0;
+    var _iterator1 = _createForOfIteratorHelper(l3Candidates),
+      _step1;
     try {
-      for (_iterator0.s(); !(_step0 = _iterator0.n()).done;) {
-        var l3c = _step0.value;
-        if (candidates.length >= MAX_CANDIDATES) break;
+      for (_iterator1.s(); !(_step1 = _iterator1.n()).done;) {
+        var l3c = _step1.value;
+        if (wordCandidates.length >= MAX_CANDIDATES) break;
         if (!existingWords.has(l3c.word)) {
-          candidates.push(l3c);
+          wordCandidates.push(l3c);
         }
       }
     } catch (err) {
-      _iterator0.e(err);
+      _iterator1.e(err);
     } finally {
-      _iterator0.f();
+      _iterator1.f();
+    }
+  }
+
+  // Multi-word completion terms (bigrams/phrases) matched on the trailing
+  // window ending at the current partial token. Runs even when the unigram path
+  // was skipped for a short partial, so first-word/early phrase matches surface.
+  var phraseCandidates = getPhraseCandidates(trimmed);
+
+  // Unify: a word completes the current partial token; a phrase completes its
+  // matched multi-word window. Track the prefix length per term so the ghost
+  // tail is sliced correctly regardless of term type.
+  var matched = [].concat(_toConsumableArray(wordCandidates.map(function (_ref) {
+    var word = _ref.word,
+      node = _ref.node;
+    return {
+      word: word,
+      node: node,
+      matchedPrefixLen: currentWord.length,
+      surfaceStart: currentWordStart
+    };
+  })), _toConsumableArray(phraseCandidates));
+  var positionCache = createCanonicalContextPositionCache();
+  var canonicalMatched = matched.map(function (candidate) {
+    return _objectSpread(_objectSpread({}, candidate), deriveCanonicalCandidateContext(trimmed, candidate.matchedPrefixLen, candidate.word, getCanonicalSurfaceTokenIds, candidate.surfaceStart, positionCache));
+  });
+  var prefixLenByWord = new Map();
+  var _iterator10 = _createForOfIteratorHelper(canonicalMatched),
+    _step10;
+  try {
+    for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
+      var m = _step10.value;
+      if (!prefixLenByWord.has(m.word)) {
+        prefixLenByWord.set(m.word, m.matchedPrefixLen);
+      }
+    }
+  } catch (err) {
+    _iterator10.e(err);
+  } finally {
+    _iterator10.f();
+  }
+  return {
+    canonicalMatched: canonicalMatched,
+    prefixLenByWord: prefixLenByWord
+  };
+};
+
+/**
+ * Recall and canonical derivation for `trimmed`, reusing the previous result
+ * when nothing they depend on has changed.
+ *
+ * `predict()` runs several times for one keystroke — once when the decision
+ * opens and again for each async evidence signal that lands inside the budget —
+ * and only the evidence differs between those runs. Without this, every run
+ * re-walks the tries and re-derives a canonical context per candidate.
+ */
+var getCanonicalRecall = function getCanonicalRecall(trimmed, currentWord, currentWordStart) {
+  var surfaceCount = getCanonicalSurfaceCount();
+  if (recallMemo !== null && recallMemo.trimmed === trimmed && recallMemo.generation === recallGeneration && recallMemo.surfaceCount === surfaceCount) {
+    return recallMemo;
+  }
+  var recall = computeCanonicalRecall(trimmed, currentWord, currentWordStart);
+  recallMemo = _objectSpread(_objectSpread({}, recall), {}, {
+    generation: recallGeneration,
+    surfaceCount: surfaceCount,
+    trimmed: trimmed
+  });
+  return recall;
+};
+export var predict = function predict(textBefore) {
+  var _trimmed$match$, _trimmed$match, _canonicalMatched$fin, _eligible$, _eligible$0$score, _eligible$2, _judgedEvidenceFor3, _prefixLenByWord$get2, _runtimeBySurface$get5, _judgedEvidenceFor$me3, _judgedEvidenceFor6, _contextTotals$get$le4, _contextTotals$get4, _selectedEvidence$ver, _selectedEvidence$tot, _selectedEvidence$ver2;
+  if (!isInitialized) {
+    // Vocabulary artifacts load asynchronously over the autocomplete gateway.
+    // Kick off the load and skip this keystroke; the plugin also primes it on
+    // focus, so the tries are usually ready before the user types.
+    void loadDefaultVocabulary({
+      source: 'predict'
+    }).catch(function () {});
+    return null;
+  }
+  var t0 = performance.now();
+
+  // Advance the post-accept cooldown once per prediction. It stays active until
+  // BOTH the keystroke budget and the time window have elapsed; while active it
+  // suppresses re-offering the just-accepted surface (see arbitration below).
+  var cooledSurface = null;
+  if (acceptCooldown) {
+    acceptCooldown.predictionsSince += 1;
+    var stillByKeys = acceptCooldown.predictionsSince <= COOLDOWN_KEYSTROKES;
+    var stillByTime = performance.now() - acceptCooldown.ts < COOLDOWN_MS;
+    if (stillByKeys || stillByTime) {
+      cooledSurface = acceptCooldown.surface;
+    } else {
+      acceptCooldown = null;
+    }
+  }
+
+  // ── Boundary/early-prefix prefetch; display remains gated at ≥3 ─────────
+  if (textBefore.length > 0 && TRAILING_WHITESPACE_REGEX.test(textBefore)) {
+    var boundaryContext = deriveWhitespaceBoundaryContext(textBefore);
+    if (boundaryContext) {
+      primeBoundaryLm(_objectSpread(_objectSpread({}, boundaryContext), {}, {
+        familyKey: boundaryContext.contextKey,
+        priority: 0
+      }));
     }
+    return null;
   }
+  var trimmed = textBefore.trimEnd();
+  var trailingSurfaceToken = (_trimmed$match$ = (_trimmed$match = trimmed.match(TRAILING_SURFACE_TOKEN_REGEX)) === null || _trimmed$match === void 0 ? void 0 : _trimmed$match[0]) !== null && _trimmed$match$ !== void 0 ? _trimmed$match$ : '';
+  if (trailingSurfaceToken.length === 0) {
+    return null;
+  }
+  var currentWord = trailingSurfaceToken;
+  var currentWordStart = trimmed.length - currentWord.length;
+  var _getCanonicalRecall = getCanonicalRecall(trimmed, currentWord, currentWordStart),
+    canonicalMatched = _getCanonicalRecall.canonicalMatched,
+    prefixLenByWord = _getCanonicalRecall.prefixLenByWord;
 
-  // If both Tries are completely empty for this prefix
-  if (candidates.length === 0) {
+  // If every trie was empty for this prefix
+  if (canonicalMatched.length === 0) {
+    if (isAutocompleteDebugEnabled()) {
+      // eslint-disable-next-line no-console
+      console.log("%c[CTC]%c \u2014 abstain: no matches for \"".concat(currentWord, "\""), CTC_STYLES.brand, CTC_STYLES.body);
+    }
     return null;
   }
   var previousWord = extractPreviousWord(trimmed);
   var contextVector = getContextVectorForScoring(trimmed);
   var lmLogits = getStoredLmLogits();
-
-  // Raw LM Output Logger
-  if (isAutocompleteDebugEnabled() && lmLogits && Object.keys(lmLogits).length > 0) {
-    var rawLmTop = Object.entries(lmLogits).sort(function (a, b) {
-      return b[1] - a[1];
-    }).slice(0, 5).map(function (_ref) {
-      var _ref2 = _slicedToArray(_ref, 2),
-        word = _ref2[0],
-        score = _ref2[1];
-      return {
-        Word: word,
-        Prob: Number(score.toFixed(5))
-      };
-    });
-    // eslint-disable-next-line no-console
-    console.log('%c[Raw LM Prediction]🧠', 'color: #e83e8c; font-weight: bold;', rawLmTop);
-  }
   var mode = contextVector ? 'warm' : 'cold';
 
-  // Build ScoringCandidate array from TrieNodes
-  var scoringCandidates = candidates.map(function (_ref3) {
-    var word = _ref3.word,
-      node = _ref3.node;
+  // Build ScoringCandidate array from matched terms (words + phrases)
+  var scoringCandidates = canonicalMatched.map(function (_ref2) {
+    var word = _ref2.word,
+      node = _ref2.node;
     return {
       word: word,
       tenantFreq: node.tenantFreq,
       docFreq: node.docFreq,
       authorFreq: node.authorFreq,
-      sessionFreq: node.sessionFreq
+      sessionFreq: node.sessionFreq,
+      termType: node.termType,
+      posSeq: node.posSeq,
+      headPos: node.headPos,
+      association: node.association
     };
   });
 
   // Filter the LM payload to only words matching the current prefix so that
   // lmMax in rankCandidates reflects prefix-relevant signal, not the global distribution.
   var prefix = currentWord.toLowerCase();
-  var prefixLmLogits = lmLogits ? Object.fromEntries(Object.entries(lmLogits).filter(function (_ref4) {
-    var _ref5 = _slicedToArray(_ref4, 1),
-      word = _ref5[0];
+  var currentWordSeparator = (_canonicalMatched$fin = canonicalMatched.find(function (candidate) {
+    return candidate.node.termType === 'word';
+  })) === null || _canonicalMatched$fin === void 0 ? void 0 : _canonicalMatched$fin.separatorKind;
+  var prefixLmLogits = lmLogits && currentWordSeparator === 'whitespace' ? Object.fromEntries(Object.entries(lmLogits).filter(function (_ref3) {
+    var _ref4 = _slicedToArray(_ref3, 1),
+      word = _ref4[0];
     return word.startsWith(prefix);
   })) : null;
+  var canonicalScoringSupported = isCanonicalSurfaceScoringSupported();
+  var eligibleContextKeys = Array.from(new Set(canonicalMatched.filter(function (candidate) {
+    return candidate.canonicalTokenIds !== null;
+  }).map(function (candidate) {
+    return candidate.contextKey;
+  }))).sort();
+  var familyKey = eligibleContextKeys.join("\x01");
+  var primeRequests = selectBoundaryPrimeRequests(familyKey, canonicalMatched, PHRASE_MAX_WORDS);
+  var _iterator11 = _createForOfIteratorHelper(primeRequests),
+    _step11;
+  try {
+    for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
+      var request = _step11.value;
+      primeBoundaryLm(request);
+    }
+  } catch (err) {
+    _iterator11.e(err);
+  } finally {
+    _iterator11.f();
+  }
+  var runtimeBySurface = new Map(canonicalMatched.map(function (candidate) {
+    return [candidate.word, candidate];
+  }));
+  var canonicalEvidence = new Map();
+  var firstTokenGroups = new Map();
+  var _iterator12 = _createForOfIteratorHelper(canonicalMatched),
+    _step12;
+  try {
+    for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
+      var _firstTokenGroups$get;
+      var _candidate = _step12.value;
+      if (_candidate.canonicalTokenIds === null) {
+        continue;
+      }
+      // This accessor also materializes an exact cache entry when all tokens
+      // have already been covered by shared-prefix work.
+      getProgressiveSurfaceEvidence(_candidate.contextKey, _candidate.word);
+      var exact = getSurfaceScore(_candidate.contextKey, _candidate.word);
+      if (exact) {
+        canonicalEvidence.set(_candidate.word, {
+          contextKey: _candidate.contextKey,
+          meanTokenLogProbability: exact.meanTokenLogProbability,
+          score: 0,
+          separatorKind: 'whitespace',
+          source: 'canonical-full-surface',
+          totalLogProbability: exact.totalLogProbability,
+          totalSurfaceCharCount: _candidate.word.length,
+          totalTokenCount: exact.tokenCount,
+          verifiedCharCount: _candidate.word.length,
+          verifiedTokenCount: exact.tokenCount
+        });
+        continue;
+      }
+      var _group2 = (_firstTokenGroups$get = firstTokenGroups.get(_candidate.contextKey)) !== null && _firstTokenGroups$get !== void 0 ? _firstTokenGroups$get : [];
+      _group2.push(_candidate);
+      firstTokenGroups.set(_candidate.contextKey, _group2);
+    }
+  } catch (err) {
+    _iterator12.e(err);
+  } finally {
+    _iterator12.f();
+  }
+  var _iterator13 = _createForOfIteratorHelper(firstTokenGroups),
+    _step13;
+  try {
+    for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
+      var _step13$value = _slicedToArray(_step13.value, 2),
+        _contextKey = _step13$value[0],
+        _group3 = _step13$value[1];
+      var boundary = getBoundaryLmState(_contextKey);
+      if (!boundary) {
+        continue;
+      }
+      var maxLogit = -Infinity;
+      var _iterator20 = _createForOfIteratorHelper(_group3),
+        _step20;
+      try {
+        for (_iterator20.s(); !(_step20 = _iterator20.n()).done;) {
+          var _candidate2$canonical;
+          var _candidate2 = _step20.value;
+          var tokenId = (_candidate2$canonical = _candidate2.canonicalTokenIds) === null || _candidate2$canonical === void 0 ? void 0 : _candidate2$canonical[0];
+          var rawLogit = tokenId === undefined ? undefined : boundary.rawLogits[tokenId];
+          if (rawLogit !== undefined && Number.isFinite(rawLogit) && rawLogit > maxLogit) {
+            maxLogit = rawLogit;
+          }
+        }
+      } catch (err) {
+        _iterator20.e(err);
+      } finally {
+        _iterator20.f();
+      }
+      if (!Number.isFinite(maxLogit)) {
+        continue;
+      }
+      var _iterator21 = _createForOfIteratorHelper(_group3),
+        _step21;
+      try {
+        for (_iterator21.s(); !(_step21 = _iterator21.n()).done;) {
+          var _candidate3$canonical, _candidate3$canonical2, _candidate3$canonical3;
+          var _candidate3 = _step21.value;
+          var _tokenId = (_candidate3$canonical = _candidate3.canonicalTokenIds) === null || _candidate3$canonical === void 0 ? void 0 : _candidate3$canonical[0];
+          var _rawLogit = _tokenId === undefined ? undefined : boundary.rawLogits[_tokenId];
+          if (_rawLogit === undefined || !Number.isFinite(_rawLogit)) {
+            continue;
+          }
+          var tokenCount = (_candidate3$canonical2 = (_candidate3$canonical3 = _candidate3.canonicalTokenIds) === null || _candidate3$canonical3 === void 0 ? void 0 : _candidate3$canonical3.length) !== null && _candidate3$canonical2 !== void 0 ? _candidate3$canonical2 : 0;
+          if (_tokenId !== undefined && tokenCount === 1) {
+            var totalLogProbability = logSoftmaxAt(boundary.rawLogits, _tokenId);
+            if (!Number.isFinite(totalLogProbability)) {
+              continue;
+            }
+            canonicalEvidence.set(_candidate3.word, {
+              contextKey: _contextKey,
+              meanTokenLogProbability: totalLogProbability,
+              score: 0,
+              separatorKind: 'whitespace',
+              source: 'canonical-full-surface',
+              totalLogProbability: totalLogProbability,
+              totalSurfaceCharCount: _candidate3.word.length,
+              totalTokenCount: 1,
+              verifiedCharCount: _candidate3.word.length,
+              verifiedTokenCount: 1
+            });
+            continue;
+          }
+          canonicalEvidence.set(_candidate3.word, {
+            contextKey: _contextKey,
+            rawLogit: _rawLogit,
+            score: 0,
+            separatorKind: 'whitespace',
+            source: 'canonical-first-token',
+            totalSurfaceCharCount: _candidate3.word.length,
+            totalTokenCount: tokenCount,
+            verifiedCharCount: 0,
+            verifiedTokenCount: 1
+          });
+        }
+      } catch (err) {
+        _iterator21.e(err);
+      } finally {
+        _iterator21.f();
+      }
+    }
+  } catch (err) {
+    _iterator13.e(err);
+  } finally {
+    _iterator13.f();
+  }
   var _rankCandidates = rankCandidates(scoringCandidates, contextVector, function (w) {
       return getWordVector(w);
-    }, prefixLmLogits, wordTrie.maxTenantFreq, previousWord),
+    }, prefixLmLogits, {
+      word: wordTrie.maxTenantFreq,
+      bigram: maxBigramFreq,
+      phrase: maxPhraseFreq
+    }, previousWord, function (surface) {
+      var _canonicalEvidence$ge;
+      return (_canonicalEvidence$ge = canonicalEvidence.get(surface)) !== null && _canonicalEvidence$ge !== void 0 ? _canonicalEvidence$ge : null;
+    }),
     ranked = _rankCandidates.candidates,
     grammarMeta = _rankCandidates.grammarMeta,
     pipelineDebug = _rankCandidates.pipelineDebug;
-  var best = ranked[0];
-  var suggestion = best && best.finalScore >= MIN_SCORE_THRESHOLD ? best.word.slice(currentWord.length) : null;
+  var progressiveEligible = ranked.filter(function (candidate) {
+    var runtime = runtimeBySurface.get(candidate.word);
+    return (runtime === null || runtime === void 0 ? void 0 : runtime.canonicalTokenIds) !== null && (runtime === null || runtime === void 0 ? void 0 : runtime.canonicalTokenIds) !== undefined;
+  });
+  if (canonicalScoringSupported && progressiveEligible.length > 0) {
+    var byContext = new Map();
+    var _iterator14 = _createForOfIteratorHelper(progressiveEligible),
+      _step14;
+    try {
+      for (_iterator14.s(); !(_step14 = _iterator14.n()).done;) {
+        var _byContext$get;
+        var candidate = _step14.value;
+        var runtime = runtimeBySurface.get(candidate.word);
+        if (!runtime || runtime.canonicalTokenIds === null) {
+          continue;
+        }
+        var group = (_byContext$get = byContext.get(runtime.contextKey)) !== null && _byContext$get !== void 0 ? _byContext$get : [];
+        group.push({
+          runtime: runtime,
+          rankHint: candidate.stage1Score
+        });
+        byContext.set(runtime.contextKey, group);
+      }
+    } catch (err) {
+      _iterator14.e(err);
+    } finally {
+      _iterator14.f();
+    }
+    var _iterator15 = _createForOfIteratorHelper(byContext),
+      _step15;
+    try {
+      for (_iterator15.s(); !(_step15 = _iterator15.n()).done;) {
+        var _step15$value = _slicedToArray(_step15.value, 2),
+          contextKey = _step15$value[0],
+          _group = _step15$value[1];
+        requestProgressiveSurfaceScores({
+          familyKey: familyKey,
+          contextKey: contextKey,
+          prompt: _group[0].runtime.contextBeforeSurface,
+          candidates: _group.map(function (_ref5) {
+            var _runtime$canonicalTok;
+            var runtime = _ref5.runtime,
+              rankHint = _ref5.rankHint;
+            return {
+              surface: runtime.word,
+              tokenIds: (_runtime$canonicalTok = runtime.canonicalTokenIds) !== null && _runtime$canonicalTok !== void 0 ? _runtime$canonicalTok : [],
+              rankHint: rankHint
+            };
+          })
+        });
+      }
+    } catch (err) {
+      _iterator15.e(err);
+    } finally {
+      _iterator15.f();
+    }
+  }
+
+  // The one/two-character passes exist only to hide model latency. They may
+  // prime and expand token groups above, but cannot commit UI.
+  var displayPrefixReady = currentWord.length >= DISPLAY_MIN_PREFIX_LENGTH;
+
+  // ── Arbitration: full-surface evidence → plausibility → winner margin ──
+  var canonicalLmSupported = canonicalScoringSupported;
+  var hasExactEvidence = function hasExactEvidence(candidate) {
+    var _candidate$lmEvidence;
+    return ((_candidate$lmEvidence = candidate.lmEvidence) === null || _candidate$lmEvidence === void 0 ? void 0 : _candidate$lmEvidence.source) === 'canonical-full-surface' && candidate.lmEvidence.meanTokenLogProbability !== undefined && Number.isFinite(candidate.lmEvidence.meanTokenLogProbability);
+  };
+
+  /**
+   * The evidence this candidate is judged on: the summed log-probability of
+   * the tokens that have been read, their per-token mean, and whether they
+   * cover the whole surface.
+   *
+   * `total` is the quantity the posterior is built from — it is a sequence
+   * log-likelihood, so it is comparable across surfaces of different lengths
+   * in a way the mean is not. `mean` is retained for reporting and for the
+   * oracle arms, which compare aggregation rules against each other.
+   *
+   * Every token read costs a round trip, so a surface longer than
+   * `REQUIRED_VERIFIED_TOKENS` is judged on its leading tokens and its tail is
+   * left unread. Callers compensate with a wider winner margin rather than
+   * treating the two kinds of evidence as equivalent.
+   *
+   * This is the depth-unaware read, and it is what the pool below is built
+   * from. Arbitration goes through `judgedEvidenceFor`, which adds the one
+   * requirement that can only be stated once the pool is known: a surface
+   * cannot be judged against members it has not yet been read level with.
+   */
+  var readJudgedEvidence = function readJudgedEvidence(candidate) {
+    var evidence = candidate.lmEvidence;
+    var exactMean = evidence === null || evidence === void 0 ? void 0 : evidence.meanTokenLogProbability;
+    if (hasExactEvidence(candidate) && evidence && exactMean !== undefined) {
+      var _evidence$totalLogPro;
+      var _total = (_evidence$totalLogPro = evidence.totalLogProbability) !== null && _evidence$totalLogPro !== void 0 ? _evidence$totalLogPro : exactMean * evidence.totalTokenCount;
+      return Number.isFinite(_total) ? {
+        complete: true,
+        mean: exactMean,
+        total: _total
+      } : null;
+    }
+    var runtime = runtimeBySurface.get(candidate.word);
+    if (!runtime || runtime.canonicalTokenIds === null) {
+      return null;
+    }
+    var progressive = getProgressiveSurfaceEvidence(runtime.contextKey, candidate.word);
+    if (!progressive || progressive.scoredTokenCount < REQUIRED_VERIFIED_TOKENS) {
+      return null;
+    }
+    var total = progressive.totalLogProbability;
+    var mean = total / progressive.scoredTokenCount;
+    return Number.isFinite(mean) && Number.isFinite(total) ? {
+      complete: false,
+      mean: mean,
+      total: total
+    } : null;
+  };
+
+  // Normalise each context's shortlist into a posterior. `total` is a sequence
+  // log-likelihood, so `exp(total - logSumExp(totals))` is the share of the
+  // shortlist's probability mass the model puts on that surface.
+  //
+  // Unknown future token log-probabilities cannot exceed zero, so a partially
+  // read candidate's total is an upper bound on its eventual total, and its
+  // posterior an upper bound on its eventual posterior. That is what lets the
+  // plausibility floor and the display gate be the same threshold — one
+  // applied to the bound, one to the verified value — instead of two numbers
+  // that have to be kept consistent by hand.
+  //
+  // Candidates with no evidence at all are left out of the sum rather than
+  // defaulted. Any default would have to stand in for a log-probability, and a
+  // value low enough not to distort the normaliser is indistinguishable from
+  // omitting the candidate.
+  var optimisticTotalByWord = new Map();
+  var contextTotals = new Map();
+  var contextSurfaces = new Map();
+  // Counted before the total is looked up, so this is every candidate the
+  // context could have scored rather than every candidate it did. The gap
+  // between the two is what separates a context holding one match from a
+  // context whose rivals have not come back yet.
+  var contextRequestedCount = new Map();
+  var bestTotalByContext = new Map();
+  var bestCandidateByContext = new Map();
+  var _iterator16 = _createForOfIteratorHelper(ranked),
+    _step16;
+  try {
+    for (_iterator16.s(); !(_step16 = _iterator16.n()).done;) {
+      var _contextRequestedCoun2, _judged$total;
+      var _candidate4 = _step16.value;
+      var _runtime = runtimeBySurface.get(_candidate4.word);
+      if (!_runtime || _runtime.canonicalTokenIds === null) {
+        continue;
+      }
+      contextRequestedCount.set(_runtime.contextKey, ((_contextRequestedCoun2 = contextRequestedCount.get(_runtime.contextKey)) !== null && _contextRequestedCoun2 !== void 0 ? _contextRequestedCoun2 : 0) + 1);
+      var judged = readJudgedEvidence(_candidate4);
+      var progressive = getProgressiveSurfaceEvidence(_runtime.contextKey, _candidate4.word);
+      // Once a candidate has been read far enough to judge, its verified total
+      // replaces the bound.
+      var optimisticTotal = (_judged$total = judged === null || judged === void 0 ? void 0 : judged.total) !== null && _judged$total !== void 0 ? _judged$total : progressive === null || progressive === void 0 ? void 0 : progressive.totalLogProbability;
+      if (optimisticTotal === undefined || !Number.isFinite(optimisticTotal)) {
+        continue;
+      }
+      optimisticTotalByWord.set(_candidate4.word, optimisticTotal);
+      var totals = contextTotals.get(_runtime.contextKey);
+      var surfaces = contextSurfaces.get(_runtime.contextKey);
+      if (totals && surfaces) {
+        totals.push(optimisticTotal);
+        surfaces.push(_candidate4.word);
+      } else {
+        contextTotals.set(_runtime.contextKey, [optimisticTotal]);
+        contextSurfaces.set(_runtime.contextKey, [_candidate4.word]);
+      }
+      var best = bestTotalByContext.get(_runtime.contextKey);
+      if (best === undefined || optimisticTotal > best) {
+        bestTotalByContext.set(_runtime.contextKey, optimisticTotal);
+        bestCandidateByContext.set(_runtime.contextKey, _candidate4);
+      }
+    }
+
+    /**
+     * Whether a shorter member of the same pool is this surface's word-boundary
+     * prefix — `happy path` where `happy` is also present.
+     *
+     * Only a multi-word surface can extend another, and a pool is a set, so this
+     * costs one lookup per space rather than a comparison against every member.
+     */
+  } catch (err) {
+    _iterator16.e(err);
+  } finally {
+    _iterator16.f();
+  }
+  var extendsAPoolMember = function extendsAPoolMember(surface, pool) {
+    for (var space = surface.indexOf(' '); space !== -1; space = surface.indexOf(' ', space + 1)) {
+      if (pool.has(surface.slice(0, space))) {
+        return true;
+      }
+    }
+    return false;
+  };
+
+  // A sequence total only falls as more of the sequence is read, so a partial
+  // sum over `k` tokens sits above the same surface's total over `m > k`. An
+  // extension read less far than the member it continues therefore carries a
+  // total above that member's — and because the chain rule narrows the
+  // denominator to the pool's minimal members, `exp(total - normaliser)` comes
+  // out above 1 for a surface whose own continuation has not been looked at.
+  // It needs a three-token first word to happen, which 2.6% of served bigrams
+  // have, and it inflates both the posterior the gate reads and the
+  // `confidenceScore` every other candidate's margin is measured against.
+  //
+  // A surface's canonical tokenization begins with the tokenization of its own
+  // leading words — the producer encodes `" " + surface` in one call and the
+  // ByteLevel pre-tokenizer splits on word boundaries, so no merge crosses a
+  // space — which is what makes both corrections below exact rather than
+  // approximate.
+  //
+  // The total is capped at what it continues: `P(happy path)` cannot exceed
+  // `P(happy)`. Shortest-first, so a three-word phrase is capped against a
+  // two-word prefix that has already been capped itself.
+  //
+  // And the surface is held unjudgeable until it has been read level with what
+  // it continues, because the cap alone would leave it looking exactly as
+  // certain as its prefix while saying nothing about its own tail.
+  var underReadExtensions = new Set();
+  var _iterator17 = _createForOfIteratorHelper(contextSurfaces),
+    _step17;
+  try {
+    for (_iterator17.s(); !(_step17 = _iterator17.n()).done;) {
+      var _step17$value = _slicedToArray(_step17.value, 2),
+        _contextKey2 = _step17$value[0],
+        _surfaces = _step17$value[1];
+      var pool = new Set(_surfaces);
+      var _iterator22 = _createForOfIteratorHelper(_toConsumableArray(_surfaces).sort(function (a, b) {
+          return a.length - b.length;
+        })),
+        _step22;
+      try {
+        for (_iterator22.s(); !(_step22 = _iterator22.n()).done;) {
+          var _getProgressiveSurfac, _getProgressiveSurfac2, _runtimeBySurface$get8, _runtimeBySurface$get9;
+          var surface = _step22.value;
+          var own = optimisticTotalByWord.get(surface);
+          if (own === undefined) {
+            continue;
+          }
+          var cap = Infinity;
+          var continuedDepth = 0;
+          for (var space = surface.indexOf(' '); space !== -1; space = surface.indexOf(' ', space + 1)) {
+            var _runtimeBySurface$get6, _runtimeBySurface$get7;
+            var _prefix = surface.slice(0, space);
+            if (!pool.has(_prefix)) {
+              continue;
+            }
+            var prefixTotal = optimisticTotalByWord.get(_prefix);
+            if (prefixTotal !== undefined && prefixTotal < cap) {
+              cap = prefixTotal;
+            }
+            var prefixDepth = (_runtimeBySurface$get6 = (_runtimeBySurface$get7 = runtimeBySurface.get(_prefix)) === null || _runtimeBySurface$get7 === void 0 || (_runtimeBySurface$get7 = _runtimeBySurface$get7.canonicalTokenIds) === null || _runtimeBySurface$get7 === void 0 ? void 0 : _runtimeBySurface$get7.length) !== null && _runtimeBySurface$get6 !== void 0 ? _runtimeBySurface$get6 : 0;
+            if (prefixDepth > continuedDepth) {
+              continuedDepth = prefixDepth;
+            }
+          }
+          if (own > cap) {
+            optimisticTotalByWord.set(surface, cap);
+          }
+          var scoredDepth = (_getProgressiveSurfac = (_getProgressiveSurfac2 = getProgressiveSurfaceEvidence(_contextKey2, surface)) === null || _getProgressiveSurfac2 === void 0 ? void 0 : _getProgressiveSurfac2.scoredTokenCount) !== null && _getProgressiveSurfac !== void 0 ? _getProgressiveSurfac : 0;
+          var surfaceDepth = (_runtimeBySurface$get8 = (_runtimeBySurface$get9 = runtimeBySurface.get(surface)) === null || _runtimeBySurface$get9 === void 0 || (_runtimeBySurface$get9 = _runtimeBySurface$get9.canonicalTokenIds) === null || _runtimeBySurface$get9 === void 0 ? void 0 : _runtimeBySurface$get9.length) !== null && _runtimeBySurface$get8 !== void 0 ? _runtimeBySurface$get8 : 0;
+          if (scoredDepth < continuedDepth && scoredDepth < surfaceDepth) {
+            underReadExtensions.add(surface);
+          }
+        }
+      } catch (err) {
+        _iterator22.e(err);
+      } finally {
+        _iterator22.f();
+      }
+    }
+
+    /**
+     * The evidence arbitration judges a candidate on.
+     *
+     * Wraps the depth-unaware read with the pool-relative requirement: a surface
+     * that continues another pool member is not judgeable until it has been read
+     * level with it, so the two totals being compared are taken at comparable
+     * depths.
+     */
+  } catch (err) {
+    _iterator17.e(err);
+  } finally {
+    _iterator17.f();
+  }
+  var judgedEvidenceFor = function judgedEvidenceFor(candidate) {
+    return underReadExtensions.has(candidate.word) ? null : readJudgedEvidence(candidate);
+  };
+  var hasJudgeableEvidence = function hasJudgeableEvidence(candidate) {
+    return judgedEvidenceFor(candidate) !== null;
+  };
+
+  // Normalise over the pool's minimal members only, and score everyone —
+  // extensions included — against that.
+  //
+  // A sequence total is its prefix's total plus a log-probability that cannot
+  // be positive, so summing a surface and its own extension double-counts:
+  // `exp(total)` for `happy` already contains every continuation of `happy`,
+  // `happy path` among them. Dividing one pool's mass between the two capped
+  // the shorter form at half however certain it was, and the longer form below
+  // that — both under gates neither could then clear, for a reason that was
+  // arithmetic rather than evidence.
+  //
+  // Excluding extensions from the denominator is the chain rule: the minimal
+  // members partition the mass, and an extension's share of that same
+  // denominator is `P(prefix) * P(continuation | prefix)`, which is exactly
+  // what a multi-word suggestion should be held to. Extensions stay in
+  // `contextTotals`, so how contested a context is still counts every scored
+  // candidate.
+  var logSumExpByContext = new Map();
+  var _iterator18 = _createForOfIteratorHelper(contextSurfaces),
+    _step18;
+  try {
+    for (_iterator18.s(); !(_step18 = _iterator18.n()).done;) {
+      var _step18$value = _slicedToArray(_step18.value, 2),
+        _contextKey3 = _step18$value[0],
+        _surfaces2 = _step18$value[1];
+      var _pool = new Set(_surfaces2);
+      var minimalTotals = [];
+      var _iterator23 = _createForOfIteratorHelper(_surfaces2),
+        _step23;
+      try {
+        for (_iterator23.s(); !(_step23 = _iterator23.n()).done;) {
+          var _surface = _step23.value;
+          var total = optimisticTotalByWord.get(_surface);
+          if (total !== undefined && !extendsAPoolMember(_surface, _pool)) {
+            minimalTotals.push(total);
+          }
+        }
+        // An extension is strictly longer than what it extends, so the shortest
+        // member of any non-empty pool is always minimal and this is never empty.
+      } catch (err) {
+        _iterator23.e(err);
+      } finally {
+        _iterator23.f();
+      }
+      logSumExpByContext.set(_contextKey3, logSumExp(minimalTotals));
+    }
+
+    /**
+     * A candidate's share of its context shortlist's probability mass.
+     *
+     * Pass an optimistic (partially read) total for an upper bound on the
+     * eventual posterior, or a verified total for the posterior itself.
+     */
+  } catch (err) {
+    _iterator18.e(err);
+  } finally {
+    _iterator18.f();
+  }
+  var posteriorFor = function posteriorFor(candidate, total) {
+    var runtime = runtimeBySurface.get(candidate.word);
+    var normalizer = runtime ? logSumExpByContext.get(runtime.contextKey) : undefined;
+    if (total === undefined || normalizer === undefined || !Number.isFinite(normalizer)) {
+      return 0;
+    }
+    return Math.exp(total - normalizer);
+  };
+  var optimisticPosterior = function optimisticPosterior(candidate) {
+    return posteriorFor(candidate, optimisticTotalByWord.get(candidate.word));
+  };
+  var judgedPosterior = function judgedPosterior(candidate) {
+    var _judgedEvidenceFor;
+    return posteriorFor(candidate, (_judgedEvidenceFor = judgedEvidenceFor(candidate)) === null || _judgedEvidenceFor === void 0 ? void 0 : _judgedEvidenceFor.total);
+  };
+
+  // A candidate stays in the race for as long as its optimistic posterior
+  // could still clear the gate it will be held to. The bound only falls as
+  // more tokens are read, so nothing dropped here could have gone on to win.
+  var couldClearGate = function couldClearGate(candidate) {
+    return optimisticPosterior(candidate) >= MIN_LM_POSTERIOR[candidate.termType];
+  };
+  var passesLmFloor = function passesLmFloor(candidate) {
+    return judgedEvidenceFor(candidate) !== null && couldClearGate(candidate);
+  };
+  var hasRequiredEvidence = function hasRequiredEvidence(candidate) {
+    var _candidate$lmEvidence2;
+    if (canonicalLmSupported) {
+      return passesLmFloor(candidate);
+    }
+    return candidate.termType === 'word' && ((_candidate$lmEvidence2 = candidate.lmEvidence) === null || _candidate$lmEvidence2 === void 0 ? void 0 : _candidate$lmEvidence2.source) === 'network-logit';
+  };
+
+  // ── Stabilization guards (QI-2) ──────────────────────────────────────────
+  // Whole-surface repetition: drop a candidate whose full surface already equals
+  // the run of tokens immediately before the cursor — accepting it would
+  // duplicate what was just typed (`end to end` → `end to end to end`).
+  var beforeTokens = tokenize(trimmed);
+  var duplicatesPreceding = function duplicatesPreceding(c) {
+    var surfaceTokens = tokenize(c.word);
+    var n = surfaceTokens.length;
+    if (n === 0 || beforeTokens.length < n) {
+      return false;
+    }
+    for (var i = 0; i < n; i++) {
+      if (beforeTokens[beforeTokens.length - n + i] !== surfaceTokens[i]) {
+        return false;
+      }
+    }
+    return true;
+  };
+  // Post-accept cooldown: don't re-offer the surface the user just accepted while
+  // its cooldown is still active (see cooldown advance near t0).
+  var isCooledDown = function isCooledDown(c) {
+    return cooledSurface !== null && c.word.toLowerCase() === cooledSurface;
+  };
+  var isStabilized = function isStabilized(candidate) {
+    return !duplicatesPreceding(candidate) && !isCooledDown(candidate);
+  };
+  // A candidate the user has all but finished typing is not worth a ghost, and
+  // a candidate we would never show is not worth waiting for either.
+  var suggestionLengthFor = function suggestionLengthFor(candidate) {
+    var _prefixLenByWord$get;
+    return candidate.word.length - ((_prefixLenByWord$get = prefixLenByWord.get(candidate.word)) !== null && _prefixLenByWord$get !== void 0 ? _prefixLenByWord$get : currentWord.length);
+  };
+  var isWorthShowing = function isWorthShowing(candidate) {
+    return suggestionLengthFor(candidate) >= MIN_SUGGESTION_LENGTH;
+  };
+  var evidenceBacked = ranked.filter(function (candidate) {
+    return hasRequiredEvidence(candidate) && isStabilized(candidate);
+  });
+  var confidenceScore = function confidenceScore(candidate) {
+    if (!canonicalLmSupported) {
+      return candidate.finalScore;
+    }
+    var runtime = runtimeBySurface.get(candidate.word);
+    if ((runtime === null || runtime === void 0 ? void 0 : runtime.canonicalTokenIds) === null || !optimisticTotalByWord.has(candidate.word)) {
+      return candidate.stage1Score;
+    }
+    return STAGE1_WEIGHT * candidate.stage1Score + STAGE2_WEIGHT * optimisticPosterior(candidate);
+  };
+  var exactConfidenceScore = function exactConfidenceScore(candidate) {
+    if (!canonicalLmSupported || judgedEvidenceFor(candidate) === null) {
+      return candidate.finalScore;
+    }
+    return STAGE1_WEIGHT * candidate.stage1Score + STAGE2_WEIGHT * judgedPosterior(candidate);
+  };
+
+  /**
+   * How many candidates in this one's context were scored at all.
+   *
+   * Read off pool membership, which counts every candidate that contributed a
+   * total, rather than off the normaliser, which the chain rule narrows to the
+   * pool's minimal members.
+   */
+  var scoredPoolSize = function scoredPoolSize(candidate) {
+    var _runtimeBySurface$get, _contextTotals$get$le, _contextTotals$get;
+    var contextKey = (_runtimeBySurface$get = runtimeBySurface.get(candidate.word)) === null || _runtimeBySurface$get === void 0 ? void 0 : _runtimeBySurface$get.contextKey;
+    return contextKey === undefined ? 0 : (_contextTotals$get$le = (_contextTotals$get = contextTotals.get(contextKey)) === null || _contextTotals$get === void 0 ? void 0 : _contextTotals$get.length) !== null && _contextTotals$get$le !== void 0 ? _contextTotals$get$le : 0;
+  };
+
+  /**
+   * How many candidates the context held before any of them were scored.
+   *
+   * A pool of one means two opposite things. Either the vocabulary offered a
+   * single continuation of what was typed, which is the least contested case
+   * there is; or rivals were offered and have not been read yet, which is the
+   * least informed. Only the second deserves refusing, and the two are
+   * distinguishable exactly here.
+   */
+  var requestedPoolSize = function requestedPoolSize(candidate) {
+    var _runtimeBySurface$get2, _contextRequestedCoun;
+    var contextKey = (_runtimeBySurface$get2 = runtimeBySurface.get(candidate.word)) === null || _runtimeBySurface$get2 === void 0 ? void 0 : _runtimeBySurface$get2.contextKey;
+    return contextKey === undefined ? 0 : (_contextRequestedCoun = contextRequestedCount.get(contextKey)) !== null && _contextRequestedCoun !== void 0 ? _contextRequestedCoun : 0;
+  };
+
+  // A suppressed short completion still counts as competition below, so losing
+  // to one abstains rather than promoting the runner-up in its place.
+  var gateCleared = evidenceBacked.filter(isWorthShowing).map(function (candidate) {
+    return {
+      candidate: candidate,
+      posterior: judgedPosterior(candidate),
+      score: exactConfidenceScore(candidate)
+    };
+  })
+  // The gate is the model's own confidence in the surface; the blended score
+  // only orders what has already cleared it, so a strong corpus prior can no
+  // longer carry a surface the model is unsure of onto the screen.
+  .filter(function (_ref6) {
+    var candidate = _ref6.candidate,
+      posterior = _ref6.posterior;
+    return posterior >= MIN_LM_POSTERIOR[candidate.termType];
+  });
+  /**
+   * Whether the model finds the surface plausible on its own terms.
+   *
+   * The gate above asks which candidate won its pool; this asks whether
+   * winning it meant anything. The two come apart exactly where a pool is
+   * thin — a shortlist of one hands its only member 1.0 by construction — and
+   * a relative test can never see through that however it is tuned.
+   *
+   * Waived without canonical scoring, where there is no judged mean to test
+   * and the network-logit path would otherwise refuse everything.
+   */
+  var isPlausibleSurface = function isPlausibleSurface(candidate) {
+    var _judgedEvidenceFor2;
+    if (!canonicalLmSupported) {
+      return true;
+    }
+    var mean = (_judgedEvidenceFor2 = judgedEvidenceFor(candidate)) === null || _judgedEvidenceFor2 === void 0 ? void 0 : _judgedEvidenceFor2.mean;
+    return mean !== undefined && mean >= MIN_MEAN_TOKEN_LOG_PROBABILITY;
+  };
+  // Kept as its own stage rather than folded into the gate so the three
+  // populations stay separable in the abstain cascade: cleared its pool and was
+  // implausible, was plausible and had nothing to clear the pool against, or
+  // cleared both. A candidate refused here stays in `ranked` and so still
+  // counts as competition below — promoting the runner-up in place of an
+  // implausible leader would show something worse, not something better.
+  var plausible = gateCleared.filter(function (_ref7) {
+    var candidate = _ref7.candidate;
+    return isPlausibleSurface(candidate);
+  });
+  // Applied after the gate rather than folded into it, so the two populations
+  // stay separable: a surface refused here cleared its threshold and was
+  // refused for having had nothing to clear it against.
+  var eligible = plausible.filter(function (_ref8) {
+    var candidate = _ref8.candidate;
+    return !canonicalLmSupported || scoredPoolSize(candidate) >= MIN_SCORED_POOL_SIZE || requestedPoolSize(candidate) <= 1;
+  }).sort(function (a, b) {
+    return b.score - a.score;
+  });
+  var selected = (_eligible$ = eligible[0]) === null || _eligible$ === void 0 ? void 0 : _eligible$.candidate;
+  var selectedDisplayScore = (_eligible$0$score = (_eligible$2 = eligible[0]) === null || _eligible$2 === void 0 ? void 0 : _eligible$2.score) !== null && _eligible$0$score !== void 0 ? _eligible$0$score : 0;
+  var selectedEvidence = selected && hasRequiredEvidence(selected) ? selected.lmEvidence : null;
+  /**
+   * Whether `longer` is `shorter` continued past a word boundary, in the same
+   * normaliser.
+   *
+   * Shared by the two places that have to agree on what an extension is: the
+   * chain rule, which stops dividing a pool's mass between a sequence and its
+   * own prefix, and the winner margin below, which stops treating one as the
+   * other's rival. They were the same category error and are now the same test.
+   */
+  var extendsInSamePool = function extendsInSamePool(shorter, longer) {
+    var _runtimeBySurface$get3, _runtimeBySurface$get4;
+    if (longer.word === shorter.word || !optimisticTotalByWord.has(longer.word)) {
+      return false;
+    }
+    var pool = (_runtimeBySurface$get3 = runtimeBySurface.get(shorter.word)) === null || _runtimeBySurface$get3 === void 0 ? void 0 : _runtimeBySurface$get3.contextKey;
+    if (pool === undefined || ((_runtimeBySurface$get4 = runtimeBySurface.get(longer.word)) === null || _runtimeBySurface$get4 === void 0 ? void 0 : _runtimeBySurface$get4.contextKey) !== pool) {
+      return false;
+    }
+    return longer.word.length > shorter.word.length && longer.word.startsWith(shorter.word) && longer.word[shorter.word.length] === ' ';
+  };
+  // A candidate that extends the selection is not competing with it. Whichever
+  // continuation the user meant, the shorter surface is a correct ghost — it is
+  // the prefix of both — so the margin has nothing to arbitrate and charging the
+  // selection for its own extension abstains on a case that could not be wrong.
+  // The chain rule already removed this from the denominator; leaving it in the
+  // margin meant a nested leader cleared its gate and then lost to the candidate
+  // that had just been freed from dividing its mass. It penalised bigrams and
+  // phrases specifically, because a nested pool is where they mostly appear.
+  var runnerUpScore = selected ? Math.max.apply(Math, _toConsumableArray(ranked.filter(function (candidate) {
+    return candidate.word !== selected.word && isStabilized(candidate) && !extendsInSamePool(selected, candidate);
+  }).map(confidenceScore)).concat([0])) : 0;
+  var winnerMargin = selected ? selectedDisplayScore - runnerUpScore : 0;
+  var hasMissingArtifactCompetitor = canonicalLmSupported && ranked.some(function (candidate) {
+    var runtime = runtimeBySurface.get(candidate.word);
+    return (runtime === null || runtime === void 0 ? void 0 : runtime.separatorKind) === 'whitespace' && runtime.canonicalTokenIds === null;
+  });
+  // A candidate with canonical tokens but no evidence at all cannot join the
+  // posterior: it has no likelihood to contribute, and any stand-in value would
+  // distort the normaliser for every other candidate in its context. Absent
+  // evidence is not evidence of absence though — the context's boundary may
+  // simply not be primed yet — so it holds the ghost back instead of being
+  // silently ignored. In a primed context every candidate has at least
+  // first-token evidence, so this only fires while a context is still cold.
+  var hasUnscoredCompetitor = canonicalLmSupported && ranked.some(function (candidate) {
+    var runtime = runtimeBySurface.get(candidate.word);
+    return candidate.word !== (selected === null || selected === void 0 ? void 0 : selected.word) && (runtime === null || runtime === void 0 ? void 0 : runtime.canonicalTokenIds) !== null && (runtime === null || runtime === void 0 ? void 0 : runtime.canonicalTokenIds) !== undefined && !optimisticTotalByWord.has(candidate.word) && isStabilized(candidate) && isWorthShowing(candidate);
+  });
+  // A rival only holds the ghost back while it is still too unread to judge.
+  // Under full-surface evidence that meant any long surface blocked everything
+  // until every one of its tokens had been paid for, which abstained far more
+  // often than it ever changed the winner. A rival now becomes judgeable after
+  // `REQUIRED_VERIFIED_TOKENS`, so this settles within the budget.
+  var hasUnresolvedPotential = canonicalLmSupported && ranked.some(function (candidate) {
+    var runtime = runtimeBySurface.get(candidate.word);
+    return candidate.word !== (selected === null || selected === void 0 ? void 0 : selected.word) && (runtime === null || runtime === void 0 ? void 0 : runtime.canonicalTokenIds) !== null && (runtime === null || runtime === void 0 ? void 0 : runtime.canonicalTokenIds) !== undefined && !hasJudgeableEvidence(candidate) && couldClearGate(candidate) && isStabilized(candidate) && isWorthShowing(candidate);
+  });
+  var requiredWinnerMargin = MIN_WINNER_MARGIN + (selected && ((_judgedEvidenceFor3 = judgedEvidenceFor(selected)) === null || _judgedEvidenceFor3 === void 0 ? void 0 : _judgedEvidenceFor3.complete) === false ? PARTIAL_EVIDENCE_MARGIN_PREMIUM : 0);
+  // Everything the display decision needs except the veto itself. Splitting it
+  // out is what lets the veto be priced: the value here at the moment the veto
+  // fires is exactly the ghost the veto cost us.
+  var clearsMarginBeforeColdVeto = selected !== undefined && !hasMissingArtifactCompetitor && winnerMargin >= requiredWinnerMargin;
+  var clearsWinnerMargin = clearsMarginBeforeColdVeto && !hasUnscoredCompetitor;
+  var suggestion = displayPrefixReady && selected && clearsWinnerMargin ? selected.word.slice((_prefixLenByWord$get2 = prefixLenByWord.get(selected.word)) !== null && _prefixLenByWord$get2 !== void 0 ? _prefixLenByWord$get2 : currentWord.length) : null;
+
+  // Which constraint bound. Computed on every evaluation rather than only under
+  // debug, because it is counted for the session as well as printed, and
+  // deriving the debug header from it keeps the two from disagreeing.
+  var resolveAbstainReason = function resolveAbstainReason() {
+    if (suggestion !== null && suggestion.length > 0) {
+      return null;
+    }
+    if (!displayPrefixReady) {
+      return 'prefetch';
+    }
+    if (ranked.length === 0) {
+      return 'no-candidate';
+    }
+    if (hasMissingArtifactCompetitor) {
+      return 'missing-artifact';
+    }
+    if (hasUnscoredCompetitor) {
+      return 'cold-competitor';
+    }
+    if (hasUnresolvedPotential && !clearsWinnerMargin) {
+      return 'unresolved-rival';
+    }
+    if (eligible.length > 0) {
+      return selected && !clearsWinnerMargin ? 'winner-margin' : 'empty-completion';
+    }
+    if (plausible.length > 0) {
+      // Cleared its gate, was plausible on its own terms, and was refused for
+      // the shortlist it cleared that gate against holding nobody else.
+      return 'lone-candidate';
+    }
+    if (gateCleared.length > 0) {
+      // Held the largest share of its shortlist and still was not a surface
+      // the model found plausible — which is only possible because a share is
+      // relative and this is not.
+      return 'implausible-surface';
+    }
+    if (evidenceBacked.length > 0 && evidenceBacked.every(function (candidate) {
+      return !isWorthShowing(candidate);
+    })) {
+      return 'short-completion';
+    }
+    // The floor and the gate are one threshold, applied to the bound and to
+    // the verified value, so a candidate short of it is dropped before
+    // `evidenceBacked` is built. Asking whether anything was judgeable
+    // separates a gate that rejected read candidates from a context where
+    // nothing was read at all — the first is a threshold to calibrate, the
+    // second is scheduling.
+    return ranked.some(hasJudgeableEvidence) ? 'below-posterior-gate' : 'no-evidence';
+  };
+  var abstainReason = resolveAbstainReason();
+
+  // The leader is the best-supported candidate, not the selected one: an
+  // evaluation that showed nothing is exactly the one whose posterior needs
+  // recording, and it has no selection to report.
+  var posteriorLeader = ranked.reduce(function (best, candidate) {
+    var posterior = optimisticPosterior(candidate);
+    return posterior > 0 && (best === null || posterior > best.posterior) ? {
+      candidate: candidate,
+      posterior: posterior
+    } : best;
+  }, null);
+  /**
+   * The longer surface in the leader's normaliser that extends the given
+   * candidate, if the pool holds one.
+   *
+   * `logSumExp` divides one pool's mass between a sequence and its own prefix,
+   * and the longer total is the shorter one plus a log-probability that cannot
+   * be positive — so the longer form holds at most half, or at most a third
+   * where both shorter forms are present. Both sit under the gate it is held
+   * to, so it cannot display however certain its continuation is.
+   *
+   * Asked from the shorter form because that is the one that leads: the
+   * extending candidate is strictly lower in the same pool and so can never be
+   * the leader.
+   */
+  var poolExtensionOf = function poolExtensionOf(shorter) {
+    return ranked.find(function (candidate) {
+      return extendsInSamePool(shorter, candidate);
+    });
+  };
   if (isAutocompleteDebugEnabled()) {
+    var _posteriorLeader$cand, _posteriorLeader$post, _selectedEvidence$mea, _selectedEvidence$mea2, _acceptCooldown$predi, _acceptCooldown;
+    var verbose = isAutocompleteDebugVerbose();
     var latencyMs = performance.now() - t0;
     var tokens = tokenize(trimmed);
     var contextWords = tokens.slice(-CONTEXT_WORDS);
-    var belowThreshold = best && best.finalScore < MIN_SCORE_THRESHOLD;
-    var suggestionLabel = belowThreshold ? '🚫 (below threshold)' : suggestion && suggestion.length > 0 ? "\u2728 \"".concat(suggestion, "\"") : '🚫 (no match)';
+
+    // Decision drives the (collapsed) group header. Abstains carry the reason
+    // the session counters recorded, plus the numbers behind it, so it is clear
+    // *why* nothing showed without expanding the group.
+    var abstainDetail = {
+      'below-posterior-gate': "posterior below ".concat(MIN_LM_POSTERIOR[((_posteriorLeader$cand = posteriorLeader === null || posteriorLeader === void 0 ? void 0 : posteriorLeader.candidate) !== null && _posteriorLeader$cand !== void 0 ? _posteriorLeader$cand : ranked[0]).termType], " (best ").concat(((_posteriorLeader$post = posteriorLeader === null || posteriorLeader === void 0 ? void 0 : posteriorLeader.posterior) !== null && _posteriorLeader$post !== void 0 ? _posteriorLeader$post : 0).toFixed(2), ")"),
+      'cold-competitor': 'competitor has no LM evidence yet',
+      'empty-completion': 'empty completion',
+      'implausible-surface': "mean per-token log-probability below ".concat(MIN_MEAN_TOKEN_LOG_PROBABILITY, " (best ").concat(gateCleared.map(function (_ref9) {
+        var _judgedEvidenceFor$me, _judgedEvidenceFor4;
+        var candidate = _ref9.candidate;
+        return (_judgedEvidenceFor$me = (_judgedEvidenceFor4 = judgedEvidenceFor(candidate)) === null || _judgedEvidenceFor4 === void 0 ? void 0 : _judgedEvidenceFor4.mean) !== null && _judgedEvidenceFor$me !== void 0 ? _judgedEvidenceFor$me : -Infinity;
+      }).reduce(function (best, mean) {
+        return Math.max(best, mean);
+      }, -Infinity).toFixed(2), ")"),
+      'lone-candidate': "cleared its gate against fewer than ".concat(MIN_SCORED_POOL_SIZE, " scored candidates, rivals unread"),
+      'missing-artifact': 'canonical artifact coverage missing',
+      'no-candidate': 'nothing cleared scoring',
+      'no-evidence': 'full-surface evidence absent',
+      prefetch: "prefetch: ".concat(currentWord.length, "/").concat(DISPLAY_MIN_PREFIX_LENGTH, " chars"),
+      'short-completion': "completion shorter than ".concat(MIN_SUGGESTION_LENGTH, " chars"),
+      'unresolved-rival': 'expanding plausible token-prefix groups',
+      'winner-margin': "winner margin ".concat(winnerMargin.toFixed(2), " < ").concat(requiredWinnerMargin.toFixed(2))
+    };
+    var decision = abstainReason === null ? "\u2728 \"".concat(suggestion !== null && suggestion !== void 0 ? suggestion : '', "\"") : abstainReason === 'prefetch' ? "\u23F3 ".concat(abstainDetail.prefetch) : "\u2014 abstain: ".concat(abstainDetail[abstainReason]);
     lastPredictionDebug = {
+      awaitingAsyncEvidence: hasUnresolvedPotential && !clearsWinnerMargin,
       textBefore: trimmed,
       currentWord: currentWord,
+      decision: decision,
       mode: mode,
       contextWords: contextWords,
       topCandidates: ranked.slice(0, 5).map(function (r) {
@@ -592,55 +1887,208 @@ export var predict = function predict(textBefore) {
       suggestion: suggestion && suggestion.length > 0 ? suggestion : null
     };
 
-    // ── Mode label: COLD / WARM(local) / WARM(BE) ───────────────────────
+    // Mode describes the semantic-vector source without implying that a
+    // network backend ran; the snapshot may come from the local MLC embedder.
     var slowLaneVec = getStoredContextVector();
     var isUsingSlowLaneVector = slowLaneVec !== null && vectorStore !== null && slowLaneVec.length === vectorStore.dim;
-    var modeLabel = !contextVector ? 'COLD' : isUsingSlowLaneVector ? 'WARM(BE)' : 'WARM(local)';
-    var modeColor = modeLabel === 'WARM(BE)' ? 'color: #ff9800; font-weight: bold;' : modeLabel === 'WARM(local)' ? 'color: #4caf50; font-weight: bold;' : 'color: #9e9e9e; font-weight: bold;';
+    var modeLabel = !contextVector ? 'COLD' : isUsingSlowLaneVector ? 'WARM(semantic)' : 'WARM(local-avg)';
+    var modeColor = modeLabel === 'WARM(semantic)' ? CTC_STYLES.good : modeLabel === 'WARM(local-avg)' ? CTC_STYLES.warn : CTC_STYLES.cold;
 
-    // 1. Collapsible group header
+    // Group header: [CTC:<mode>] <decision> · <mode> · <type> · <latency>
+    // arbitrationMode ('v1') tags the line so this deploy's logs diff cleanly
+    // against the baseline deploy's.
     // eslint-disable-next-line no-console
-    console.groupCollapsed("%c[Autocomplete] %c".concat(modeLabel, " %c| \"").concat(currentWord, "\" \u2794 ").concat(suggestionLabel, " | \u23F1 ").concat(latencyMs.toFixed(1), "ms"), 'color: #00b8d9; font-weight: bold;', modeColor, 'color: inherit; font-weight: normal;');
+    console.groupCollapsed("%c[CTC:".concat(ARBITRATION_MODE, "]%c ").concat(decision, " %c\xB7 ").concat(modeLabel).concat(selected ? " \xB7 ".concat(selected.termType) : '', " \xB7 \u23F1 ").concat(latencyMs.toFixed(1), "ms"), CTC_STYLES.brand, CTC_STYLES.body, modeColor);
+    var semanticInput = getStoredContextInput();
+    var causalPrompts = primeRequests.map(function (request, index) {
+      var tail = request.prompt.slice(-DEBUG_TEXT_TAIL_CHARS);
+      return "#".concat(index + 1, ":").concat(JSON.stringify(tail));
+    });
 
-    // 2. Context window (what local vector averaging sees)
-    // eslint-disable-next-line no-console
-    console.log('%cContext Window:', 'color: #888; font-style: italic;', contextWords.length ? contextWords.join(' ') : '(none)');
+    // Keep the exact model inputs separate from normalized lookup tokens.
+    ctcSection('INPUT', "raw: ".concat(JSON.stringify(trimmed.slice(-DEBUG_TEXT_TAIL_CHARS)), " \xB7 prev: ").concat(previousWord ? JSON.stringify(previousWord) : '—'));
+    ctcSection('LOOKUP', "normalized(last ".concat(CONTEXT_WORDS, "): ").concat(contextWords.length ? JSON.stringify(contextWords.join(' ')) : '(none)'));
+    ctcSection('SEMANTIC', "snapshot: ".concat(semanticInput ? JSON.stringify(semanticInput.slice(-DEBUG_TEXT_TAIL_CHARS)) : '(unavailable)'));
+    ctcSection('CAUSAL', "prompt".concat(causalPrompts.length === 1 ? '' : 's', ": ").concat(causalPrompts.join(' · ') || '(not ready)'));
 
-    // 3. Slow-lane status
-    var vectorStatus = isUsingSlowLaneVector ? "\u2705 BE semantic vector (dim=".concat(slowLaneVec === null || slowLaneVec === void 0 ? void 0 : slowLaneVec.length, ")") : vectorStore ? '⚠️ Local vector average (slow-lane not yet returned)' : '❌ No vectors (cold)';
-    var logitsStatus = lmLogits && Object.keys(lmLogits).length > 0 ? "\u2705 LM logits active (".concat(Object.keys(lmLogits).length, " tokens)") : '⏳ No LM logits (slow-lane pending or failed)';
-    // eslint-disable-next-line no-console
-    console.log('%cSlow Lane:', 'color: #888; font-style: italic;', vectorStatus, '|', logitsStatus);
+    // SIGNALS — semantic state plus context-keyed canonical LM coverage.
+    var logitCount = lmLogits ? Object.keys(lmLogits).length : 0;
+    var semanticStatus = isUsingSlowLaneVector ? "semantic \u2705 snapshot(".concat(slowLaneVec === null || slowLaneVec === void 0 ? void 0 : slowLaneVec.length, "d)") : vectorStore ? 'semantic ⚠️ local-avg' : 'semantic ❌ cold';
+    var tierACount = ranked.filter(function (candidate) {
+      var _candidate$lmEvidence3;
+      return ((_candidate$lmEvidence3 = candidate.lmEvidence) === null || _candidate$lmEvidence3 === void 0 ? void 0 : _candidate$lmEvidence3.source) === 'canonical-first-token';
+    }).length;
+    var exactCount = ranked.filter(function (candidate) {
+      var _candidate$lmEvidence4;
+      return ((_candidate$lmEvidence4 = candidate.lmEvidence) === null || _candidate$lmEvidence4 === void 0 ? void 0 : _candidate$lmEvidence4.source) === 'canonical-full-surface';
+    }).length;
+    var boundaryReady = primeRequests.filter(function (request) {
+      return getBoundaryLmState(request.contextKey) !== null;
+    }).length;
+    var artifactEligible = canonicalMatched.filter(function (candidate) {
+      return candidate.canonicalTokenIds !== null;
+    }).length;
+    var documentStartFallbacks = canonicalMatched.filter(function (candidate) {
+      return candidate.separatorKind === 'document-start';
+    }).length;
+    var punctuationFallbacks = canonicalMatched.filter(function (candidate) {
+      return candidate.separatorKind === 'non-space';
+    }).length;
+    var logitsStatus = tierACount + exactCount > 0 ? "canonical \u2705 first-token:".concat(tierACount, " exact:").concat(exactCount) : logitCount > 0 ? "network logits \u2705 ".concat(logitCount) : 'canonical ⏳/absent';
+    var formula = tierACount + exactCount + logitCount > 0 ? "Stage1\xD7".concat(STAGE1_WEIGHT, "+LM\xD7").concat(STAGE2_WEIGHT) : 'Stage1-only';
+    ctcSection('SIGNALS', "".concat(semanticStatus, " \xB7 ").concat(logitsStatus, " \xB7 ").concat(formula));
+    ctcSection('CANONICAL', "eligible ".concat(artifactEligible, "/").concat(canonicalMatched.length, " \xB7 separator fallback doc:").concat(documentStartFallbacks, " punct:").concat(punctuationFallbacks, " \xB7 contexts ").concat(boundaryReady, "/").concat(primeRequests.length, " ready (\u2264").concat(PHRASE_MAX_WORDS, ") \xB7 family=").concat(familyKey.slice(0, 72) || 'none'));
+    if (verbose && logitCount > 0 && lmLogits) {
+      var rawLmTop = Object.entries(lmLogits).sort(function (a, b) {
+        return b[1] - a[1];
+      }).slice(0, 5).map(function (_ref0) {
+        var _ref1 = _slicedToArray(_ref0, 2),
+          word = _ref1[0],
+          score = _ref1[1];
+        return "".concat(word, ":").concat(score.toFixed(3));
+      }).join(', ');
+      ctcSection('  rawLM', "\uD83E\uDDE0 ".concat(rawLmTop));
+    }
 
-    // 4. Scoring formula active this prediction
-    var formulaLabel = lmLogits && Object.keys(lmLogits).length > 0 ? "Stage1(\xD7".concat(STAGE1_WEIGHT, ") + LM(\xD7").concat(STAGE2_WEIGHT, ")") : 'Stage1 only (no LM logits)';
-    // eslint-disable-next-line no-console
-    console.log('%cFormula:', 'color: #888; font-style: italic;', formulaLabel);
+    // GENERATE — how many candidates matched, split by term type
+    var genByType = {
+      word: 0,
+      bigram: 0,
+      phrase: 0
+    };
+    var _iterator19 = _createForOfIteratorHelper(canonicalMatched),
+      _step19;
+    try {
+      for (_iterator19.s(); !(_step19 = _iterator19.n()).done;) {
+        var m = _step19.value;
+        genByType[m.node.termType] += 1;
+      }
+    } catch (err) {
+      _iterator19.e(err);
+    } finally {
+      _iterator19.f();
+    }
+    ctcSection('GENERATE', "matched ".concat(canonicalMatched.length, " \u2192 word:").concat(genByType.word, " bigram:").concat(genByType.bigram, " phrase:").concat(genByType.phrase).concat(canonicalLmSupported ? ' · display needs exact surface evidence' : ''));
 
-    // 5. Grammar filter result (collected inside rankCandidates, logged here)
+    // SCORE — Stage-1 + grammar funnel and canonical evidence depth.
+    var lmCoverage = ranked.slice(0, 10).filter(function (r) {
+      return r.lmScore > 0;
+    }).length;
+    ctcSection('SCORE', "in ".concat(pipelineDebug.initial, " \u2192 stage1(<").concat(MIN_STAGE1_SCORE, ") \u2212").concat(pipelineDebug.stage1Rejected.length, " \u2192 grammar \u2212").concat(pipelineDebug.grammarRejected.length, " \u2192 final ").concat(pipelineDebug.final, " \xB7 LM cov ").concat(lmCoverage, "/").concat(Math.min(ranked.length, 10), " \xB7 first-token ").concat(tierACount, " \xB7 exact ").concat(exactCount));
     if (grammarMeta) {
-      // eslint-disable-next-line no-console
-      console.log("%c[Grammar] \"".concat(grammarMeta.prevWord, "\" [").concat(grammarMeta.prevTags.join('|'), "] \u2192 ").concat(grammarMeta.before, " candidates \u2192 ").concat(grammarMeta.after, " after filter"), 'color: #4caf50; font-weight: bold;');
-      if (grammarMeta.dropped.length > 0) {
-        // eslint-disable-next-line no-console
-        console.log("%c\uD83D\uDEAB Dropped: ".concat(grammarMeta.dropped.join(', ')), 'color: #f44336; font-style: italic;');
-      }
+      ctcSection('  grammar', "\"".concat(grammarMeta.prevWord, "\" [").concat(grammarMeta.prevTags.join('|'), "] ").concat(grammarMeta.before, "\u2192").concat(grammarMeta.after).concat(verbose && grammarMeta.dropped.length > 0 ? " \xB7 dropped: ".concat(grammarMeta.dropped.join(', ')) : ''));
     }
+    var gateReasonFor = function gateReasonFor(candidate) {
+      var runtime = runtimeBySurface.get(candidate.word);
+      if ((runtime === null || runtime === void 0 ? void 0 : runtime.separatorKind) !== 'whitespace') {
+        var _runtime$separatorKin;
+        return "separator:".concat((_runtime$separatorKin = runtime === null || runtime === void 0 ? void 0 : runtime.separatorKind) !== null && _runtime$separatorKin !== void 0 ? _runtime$separatorKin : 'unknown');
+      }
+      if (runtime.canonicalTokenIds === null) {
+        return 'missing-artifact';
+      }
+      if (!hasJudgeableEvidence(candidate)) {
+        return "awaiting-tokens:".concat(REQUIRED_VERIFIED_TOKENS);
+      }
+      if (!passesLmFloor(candidate)) {
+        return "bound:".concat(optimisticPosterior(candidate).toFixed(2), "<").concat(MIN_LM_POSTERIOR[candidate.termType]);
+      }
+      if (duplicatesPreceding(candidate)) {
+        return 'repetition';
+      }
+      if (isCooledDown(candidate)) {
+        return 'cooldown';
+      }
+      if (!isWorthShowing(candidate)) {
+        return "suffix:".concat(suggestionLengthFor(candidate), "<").concat(MIN_SUGGESTION_LENGTH);
+      }
+      var floor = MIN_LM_POSTERIOR[candidate.termType];
+      var posterior = judgedPosterior(candidate);
+      if (posterior < floor) {
+        return "posterior:".concat(posterior.toFixed(2), "<").concat(floor);
+      }
+      if (!isPlausibleSurface(candidate)) {
+        var _judgedEvidenceFor$me2, _judgedEvidenceFor5;
+        return "implausible:".concat(((_judgedEvidenceFor$me2 = (_judgedEvidenceFor5 = judgedEvidenceFor(candidate)) === null || _judgedEvidenceFor5 === void 0 ? void 0 : _judgedEvidenceFor5.mean) !== null && _judgedEvidenceFor$me2 !== void 0 ? _judgedEvidenceFor$me2 : NaN).toFixed(2), "<").concat(MIN_MEAN_TOKEN_LOG_PROBABILITY);
+      }
+      return 'eligible';
+    };
+    var gateFunnel = function gateFunnel(termType) {
+      var typeRanked = ranked.filter(function (candidate) {
+        return candidate.termType === termType;
+      });
+      var exact = typeRanked.filter(hasJudgeableEvidence);
+      var absolute = exact.filter(passesLmFloor);
+      var stabilized = absolute.filter(isStabilized);
+      var longEnough = stabilized.filter(isWorthShowing);
+      var floorPassed = longEnough.filter(function (candidate) {
+        return judgedPosterior(candidate) >= MIN_LM_POSTERIOR[termType];
+      });
+      var plausiblePassed = floorPassed.filter(isPlausibleSurface);
+      return "".concat(termType, " m:").concat(genByType[termType], " r:").concat(typeRanked.length, " exact:").concat(exact.length, " abs:").concat(absolute.length, " stable:").concat(stabilized.length, " suffix:").concat(longEnough.length, " floor:").concat(floorPassed.length, " plausible:").concat(plausiblePassed.length, " eligible:").concat(eligible.filter(function (_ref10) {
+        var candidate = _ref10.candidate;
+        return candidate.termType === termType;
+      }).length);
+    };
+    ctcSection('GATES', "".concat(gateFunnel('word'), "  |  ").concat(gateFunnel('bigram'), "  |  ").concat(gateFunnel('phrase')));
 
-    // 6. Pipeline funnel
-    // eslint-disable-next-line no-console
-    console.log("%c[Pipeline Funnel] %c\uD83D\uDCE5 In: ".concat(pipelineDebug.initial, " | \u274C Stage 1 (< ").concat(MIN_STAGE1_SCORE, "): -").concat(pipelineDebug.stage1Rejected.length, " | \u274C Grammar: -").concat(pipelineDebug.grammarRejected.length, " | \u2705 Final: ").concat(pipelineDebug.final), 'color: #9c27b0; font-weight: bold;', 'color: inherit;');
+    // One line per context: how many candidates share the normaliser, and how
+    // much of the mass the leader holds. A leader well under its threshold
+    // means the context is contested, which is the abstention we want.
+    var contextLeaders = Array.from(bestCandidateByContext.entries()).slice(0, PHRASE_MAX_WORDS).map(function (_ref11) {
+      var _contextTotals$get$le2, _contextTotals$get2;
+      var _ref12 = _slicedToArray(_ref11, 2),
+        contextKey = _ref12[0],
+        leader = _ref12[1];
+      var shortlistSize = (_contextTotals$get$le2 = (_contextTotals$get2 = contextTotals.get(contextKey)) === null || _contextTotals$get2 === void 0 ? void 0 : _contextTotals$get2.length) !== null && _contextTotals$get$le2 !== void 0 ? _contextTotals$get$le2 : 0;
+      var evidenceKind = hasExactEvidence(leader) ? 'exact' : 'upper';
+      return "".concat(contextKey.slice(0, 32), " \u2192 n=").concat(shortlistSize, " ").concat(leader.termType, ":\"").concat(leader.word, "\" ").concat(evidenceKind, " p=").concat(optimisticPosterior(leader).toFixed(3), "/").concat(MIN_LM_POSTERIOR[leader.termType]);
+    }).join(' | ');
+    ctcSection('NORMALIZE', contextLeaders.length > 0 ? contextLeaders : 'no scored candidate in any context');
+    ctcSection('READINESS', "prefix ".concat(currentWord.length, "/").concat(DISPLAY_MIN_PREFIX_LENGTH, " \xB7 boundary ").concat(boundaryReady, "/").concat(primeRequests.length, " \xB7 exact word:").concat(ranked.filter(function (candidate) {
+      return candidate.termType === 'word' && hasExactEvidence(candidate);
+    }).length, " bigram:").concat(ranked.filter(function (candidate) {
+      return candidate.termType === 'bigram' && hasExactEvidence(candidate);
+    }).length, " phrase:").concat(ranked.filter(function (candidate) {
+      return candidate.termType === 'phrase' && hasExactEvidence(candidate);
+    }).length, " \xB7 ").concat(suggestion ? 'display-ready' : decision));
 
-    // 7. Candidate table
-    if (ranked.length > 0) {
-      var lmCoverage = ranked.slice(0, 10).filter(function (r) {
-        return r.lmScore > 0;
-      }).length;
-      // eslint-disable-next-line no-console
-      console.log("%cLM coverage: ".concat(lmCoverage, "/").concat(Math.min(ranked.length, 10), " candidates had real logit scores"), 'color: #888; font-style: italic;');
+    // ARBITRATE — expose every condition that can authorize or suppress ghost.
+    var topOfType = function topOfType(t) {
+      return ranked.find(function (c) {
+        return c.termType === t;
+      });
+    };
+    var fmtType = function fmtType(t) {
+      var _top$lmEvidence$sourc, _top$lmEvidence;
+      var top = topOfType(t);
+      if (!top) {
+        return "".concat(t, ":\u2014");
+      }
+      var floor = MIN_LM_POSTERIOR[t];
+      var bound = optimisticPosterior(top);
+      var evidence = hasRequiredEvidence(top) ? 'TierB✅' : "".concat((_top$lmEvidence$sourc = (_top$lmEvidence = top.lmEvidence) === null || _top$lmEvidence === void 0 ? void 0 : _top$lmEvidence.source) !== null && _top$lmEvidence$sourc !== void 0 ? _top$lmEvidence$sourc : 'absent', "\u274C");
+      return "".concat(t, ":\"").concat(top.word, "\" p\u2264").concat(bound.toFixed(3)).concat(bound >= floor ? '≥' : '<').concat(floor, " fs\u2264").concat(confidenceScore(top).toFixed(2), " ").concat(evidence);
+    };
+    ctcSection('ARBITRATE', "".concat(selected ? "\u25B8 ".concat(selected.termType, " \"").concat(selected.word, "\" fs=").concat(selectedDisplayScore.toFixed(2), " mean=").concat((_selectedEvidence$mea = selectedEvidence === null || selectedEvidence === void 0 || (_selectedEvidence$mea2 = selectedEvidence.meanTokenLogProbability) === null || _selectedEvidence$mea2 === void 0 ? void 0 : _selectedEvidence$mea2.toFixed(2)) !== null && _selectedEvidence$mea !== void 0 ? _selectedEvidence$mea : 'network', " margin=").concat(winnerMargin.toFixed(2)).concat(clearsWinnerMargin ? '✅' : '❌') : '▸ (none)', " \xB7 prefix ").concat(currentWord.length, "/").concat(DISPLAY_MIN_PREFIX_LENGTH).concat(displayPrefixReady ? '✅' : '⏳', " \xB7 grouped pending ").concat(hasUnresolvedPotential ? 'yes' : 'no', "  |  ").concat(fmtType('word'), "  ").concat(fmtType('bigram'), "  ").concat(fmtType('phrase')));
+
+    // STABILIZE — post-accept cooldown + whole-surface repetition (QI-2)
+    var repetitionBlocked = ranked.filter(function (c) {
+      return hasRequiredEvidence(c) && duplicatesPreceding(c);
+    }).map(function (c) {
+      return c.word;
+    });
+    var cooldownLabel = cooledSurface ? "cooldown \"".concat(cooledSurface, "\" (").concat((_acceptCooldown$predi = (_acceptCooldown = acceptCooldown) === null || _acceptCooldown === void 0 ? void 0 : _acceptCooldown.predictionsSince) !== null && _acceptCooldown$predi !== void 0 ? _acceptCooldown$predi : 0, "/").concat(COOLDOWN_KEYSTROKES, " keys \xB7 ").concat(COOLDOWN_MS, "ms)") : 'cooldown —';
+    ctcSection('STABILIZE', "".concat(cooldownLabel, " \xB7 repetition-blocked: ").concat(repetitionBlocked.length > 0 ? repetitionBlocked.join(', ') : '—'));
+
+    // CANDIDATES — full scored table (verbose only)
+    if (verbose && ranked.length > 0) {
       var tableData = ranked.slice(0, 10).map(function (r) {
+        var _r$lmEvidence, _contextTotals$get$le3, _contextTotals$get3, _r$lmEvidence$source, _r$lmEvidence2, _runtime$separatorKin2, _runtime$canonicalTok2, _runtime$canonicalTok3, _runtime$contextKey, _r$lmEvidence3, _r$lmEvidence4;
         var rawLogit = 'Not in Payload';
-        if (prefixLmLogits) {
+        if (((_r$lmEvidence = r.lmEvidence) === null || _r$lmEvidence === void 0 ? void 0 : _r$lmEvidence.rawLogit) !== undefined) {
+          rawLogit = Number(r.lmEvidence.rawLogit.toFixed(5));
+        } else if (prefixLmLogits) {
           var val = prefixLmLogits[r.word.toLowerCase()];
           if (val !== undefined) {
             rawLogit = Number(val.toFixed(5));
@@ -649,9 +2097,19 @@ export var predict = function predict(textBefore) {
         var original = scoringCandidates.find(function (sc) {
           return sc.word === r.word;
         });
+        var runtime = runtimeBySurface.get(r.word);
+        var progress = runtime ? getProgressiveSurfaceEvidence(runtime.contextKey, r.word) : null;
+        var optimisticTotal = optimisticTotalByWord.get(r.word);
+        var normalizer = runtime ? logSumExpByContext.get(runtime.contextKey) : undefined;
+        var shortlistSize = runtime ? (_contextTotals$get$le3 = (_contextTotals$get3 = contextTotals.get(runtime.contextKey)) === null || _contextTotals$get3 === void 0 ? void 0 : _contextTotals$get3.length) !== null && _contextTotals$get$le3 !== void 0 ? _contextTotals$get$le3 : 0 : 0;
+        var contextLeader = runtime ? bestCandidateByContext.get(runtime.contextKey) : undefined;
         var source = 'Unknown';
         if (original) {
-          if (original.docFreq === 0 && original.tenantFreq === L3_BASELINE_FREQ) {
+          if (original.termType === 'bigram') {
+            source = '🔗 L2 (Bigram)';
+          } else if (original.termType === 'phrase') {
+            source = '🧩 L2 (Phrase)';
+          } else if (original.docFreq === 0 && original.tenantFreq === L3_BASELINE_FREQ) {
             source = '🌍 L3 (Generic)';
           } else if (original.sessionFreq > 0 && original.tenantFreq === 0) {
             source = '👤 L1 (Session Only)';
@@ -659,13 +2117,40 @@ export var predict = function predict(textBefore) {
             source = '🏢 L2 (Domain)';
           }
         }
+        var floor = MIN_LM_POSTERIOR[r.termType];
         return {
           Candidate: r.word,
           Source: source,
+          Type: r.termType,
           'Final Score': Number(r.finalScore.toFixed(4)),
+          'Bounded Score': Number(confidenceScore(r).toFixed(4)),
+          'Exact Gate Score': hasExactEvidence(r) ? Number(exactConfidenceScore(r).toFixed(4)) : '—',
+          Floor: floor,
+          'Posterior Floor': optimisticPosterior(r) >= floor ? '✅' : '❌',
+          'LM Floor': hasExactEvidence(r) ? passesLmFloor(r) ? '✅' : '❌' : '⏳',
+          'Gate Reason': gateReasonFor(r),
+          'Display Eligible': hasRequiredEvidence(r) && isStabilized(r) && judgedPosterior(r) >= floor ? '✅' : '❌',
           Semantics: Number(r.semanticScore.toFixed(4)),
           Freq: Number(r.freqScore.toFixed(4)),
           'LM Score': Number(r.lmScore.toFixed(4)),
+          'LM Evidence': (_r$lmEvidence$source = (_r$lmEvidence2 = r.lmEvidence) === null || _r$lmEvidence2 === void 0 ? void 0 : _r$lmEvidence2.source) !== null && _r$lmEvidence$source !== void 0 ? _r$lmEvidence$source : 'absent',
+          'Verified Tokens': r.lmEvidence ? "".concat(r.lmEvidence.verifiedTokenCount, "/").concat(r.lmEvidence.totalTokenCount) : '0/0',
+          'Progressive Tokens': progress ? "".concat(progress.scoredTokenCount, "/").concat(progress.totalTokenCount) : '0/0',
+          'LM Mean Upper': progress !== null ? Number(progress.meanTokenLogProbabilityUpperBound.toFixed(5)) : '—',
+          'Optimistic Total': optimisticTotal !== undefined ? Number(optimisticTotal.toFixed(5)) : '—',
+          'Context logSumExp': normalizer !== undefined && Number.isFinite(normalizer) ? Number(normalizer.toFixed(5)) : '—',
+          'Shortlist Size': shortlistSize,
+          'Posterior (bound)': Number(optimisticPosterior(r).toFixed(5)),
+          'Posterior (judged)': hasJudgeableEvidence(r) ? Number(judgedPosterior(r).toFixed(5)) : '—',
+          'Context Leader': contextLeader ? "".concat(contextLeader.termType, ":").concat(contextLeader.word) : '—',
+          'Verified Chars': r.lmEvidence ? "".concat(r.lmEvidence.verifiedCharCount, "/").concat(r.lmEvidence.totalSurfaceCharCount) : "0/".concat(r.word.length),
+          Separator: (_runtime$separatorKin2 = runtime === null || runtime === void 0 ? void 0 : runtime.separatorKind) !== null && _runtime$separatorKin2 !== void 0 ? _runtime$separatorKin2 : 'unknown',
+          'Canonical Eligibility': (runtime === null || runtime === void 0 ? void 0 : runtime.separatorKind) !== 'whitespace' ? 'incompatible-separator' : runtime.canonicalTokenIds === null ? 'missing-artifact' : 'eligible',
+          'Artifact Tokens': (_runtime$canonicalTok2 = runtime === null || runtime === void 0 || (_runtime$canonicalTok3 = runtime.canonicalTokenIds) === null || _runtime$canonicalTok3 === void 0 ? void 0 : _runtime$canonicalTok3.join(',')) !== null && _runtime$canonicalTok2 !== void 0 ? _runtime$canonicalTok2 : 'absent',
+          'Context Key': (_runtime$contextKey = runtime === null || runtime === void 0 ? void 0 : runtime.contextKey) !== null && _runtime$contextKey !== void 0 ? _runtime$contextKey : '—',
+          'Exact Total': ((_r$lmEvidence3 = r.lmEvidence) === null || _r$lmEvidence3 === void 0 ? void 0 : _r$lmEvidence3.totalLogProbability) !== undefined ? Number(r.lmEvidence.totalLogProbability.toFixed(5)) : '—',
+          'Exact Mean': ((_r$lmEvidence4 = r.lmEvidence) === null || _r$lmEvidence4 === void 0 ? void 0 : _r$lmEvidence4.meanTokenLogProbability) !== undefined ? Number(r.lmEvidence.meanTokenLogProbability.toFixed(5)) : '—',
+          Assoc: typeof (original === null || original === void 0 ? void 0 : original.association) === 'number' ? Number(original.association.toFixed(4)) : '—',
           'Raw Logit': rawLogit,
           'Session Freq': (original === null || original === void 0 ? void 0 : original.sessionFreq) || 0
         };
@@ -673,23 +2158,120 @@ export var predict = function predict(textBefore) {
 
       // eslint-disable-next-line no-console
       console.table(tableData);
-    } else {
-      // eslint-disable-next-line no-console
-      console.log('No candidates found.');
     }
 
     // eslint-disable-next-line no-console
     console.groupEnd();
   }
-  return suggestion && suggestion.length > 0 ? suggestion : null;
+  var selectedContextKey = selected ? (_runtimeBySurface$get5 = runtimeBySurface.get(selected.word)) === null || _runtimeBySurface$get5 === void 0 ? void 0 : _runtimeBySurface$get5.contextKey : undefined;
+  return suggestion && suggestion.length > 0 && selected && selectedEvidence ? {
+    text: suggestion,
+    surface: selected.word,
+    termType: selected.termType,
+    posterior: judgedPosterior(selected),
+    meanTokenLogProbability: (_judgedEvidenceFor$me3 = (_judgedEvidenceFor6 = judgedEvidenceFor(selected)) === null || _judgedEvidenceFor6 === void 0 ? void 0 : _judgedEvidenceFor6.mean) !== null && _judgedEvidenceFor$me3 !== void 0 ? _judgedEvidenceFor$me3 : NaN,
+    poolHeldExtension: poolExtensionOf(selected) !== undefined,
+    shortlistSize: selectedContextKey === undefined ? 1 : (_contextTotals$get$le4 = (_contextTotals$get4 = contextTotals.get(selectedContextKey)) === null || _contextTotals$get4 === void 0 ? void 0 : _contextTotals$get4.length) !== null && _contextTotals$get$le4 !== void 0 ? _contextTotals$get$le4 : 1,
+    rankScore: selectedDisplayScore,
+    evidenceTier: (selectedEvidence === null || selectedEvidence === void 0 ? void 0 : selectedEvidence.source) === 'network-logit' ? 'network-logit' : 'canonical-full-surface',
+    evidenceDepth: {
+      verifiedTokens: (_selectedEvidence$ver = selectedEvidence === null || selectedEvidence === void 0 ? void 0 : selectedEvidence.verifiedTokenCount) !== null && _selectedEvidence$ver !== void 0 ? _selectedEvidence$ver : 0,
+      totalTokens: (_selectedEvidence$tot = selectedEvidence === null || selectedEvidence === void 0 ? void 0 : selectedEvidence.totalTokenCount) !== null && _selectedEvidence$tot !== void 0 ? _selectedEvidence$tot : 0,
+      verifiedChars: (_selectedEvidence$ver2 = selectedEvidence === null || selectedEvidence === void 0 ? void 0 : selectedEvidence.verifiedCharCount) !== null && _selectedEvidence$ver2 !== void 0 ? _selectedEvidence$ver2 : 0,
+      totalChars: selected.word.length
+    },
+    winnerMargin: winnerMargin
+  } : null;
 };
 
 // ─── Data Loading ────────────────────────────────────────────────────────────
 
+var isVocabularyJson = function isVocabularyJson(payload) {
+  if (payload == null || _typeof(payload) !== 'object') {
+    return false;
+  }
+  var words = payload.words;
+  return words != null && _typeof(words) === 'object';
+};
+var isStringArray = function isStringArray(payload) {
+  return Array.isArray(payload) && payload.every(function (entry) {
+    return typeof entry === 'string';
+  });
+};
+var isWordToOffsetMap = function isWordToOffsetMap(value) {
+  return value != null && _typeof(value) === 'object' && Object.values(value).every(function (entry) {
+    return typeof entry === 'number';
+  });
+};
+var isWordIndexPayload = function isWordIndexPayload(payload) {
+  if (payload == null || _typeof(payload) !== 'object') {
+    return false;
+  }
+  var index = payload.index;
+  return index === undefined ? isWordToOffsetMap(payload) : isWordToOffsetMap(index);
+};
+
+/**
+ * The word index has shipped both bare and wrapped in `{ index: ... }`, so
+ * accept either rather than silently building an empty vector store.
+ */
+var unwrapWordIndex = function unwrapWordIndex(payload) {
+  var wrapped = payload.index;
+  return wrapped !== null && wrapped !== void 0 ? wrapped : payload;
+};
+
+/**
+ * Per-term stats shape for `bigrams.json` / `phrases.json`. Field names/types
+ * confirmed against the producer (`l2_vocabulary_creation._build_ngram_stat_payload`
+ * + `artifact_release._validate_ngram_payload`): `freq`/`doc_freq`/`author_freq`
+ * are ints, `pos_seq` a string array, `head_pos` a string or null, `association`
+ * a number.
+ */
+
+/** Normalized `{term: stats}` map after unwrapping any producer wrapper key. */
+
+var isPhraseStats = function isPhraseStats(value) {
+  return value != null && _typeof(value) === 'object' && typeof value.freq === 'number';
+};
+var isTermStatsMap = function isTermStatsMap(value) {
+  if (value == null || _typeof(value) !== 'object') {
+    return false;
+  }
+  var values = Object.values(value);
+  return values.length > 0 && values.every(isPhraseStats);
+};
+
+/**
+ * Normalize a `bigrams.json` / `phrases.json` payload into a flat
+ * `{term: stats}` map. Tolerant of the exact wire shape (not yet finalized by
+ * the producer): accepts either the flat map from spec §9 or a single wrapper
+ * key (`terms`/`bigrams`/`phrases`/`words`). Returns `null` if unrecognized.
+ *
+ * :params:
+ *   payload: Raw JSON parsed from the artifact endpoint
+ * :returns:
+ *   A `{term: stats}` map, or `null` when the shape is not a term-stats map
+ */
+var normalizePhraseArtifact = function normalizePhraseArtifact(payload) {
+  if (payload == null || _typeof(payload) !== 'object') {
+    return null;
+  }
+  if (isTermStatsMap(payload)) {
+    return payload;
+  }
+  var obj = payload;
+  for (var _i4 = 0, _arr = ['terms', 'bigrams', 'phrases', 'words']; _i4 < _arr.length; _i4++) {
+    var key = _arr[_i4];
+    if (isTermStatsMap(obj[key])) {
+      return obj[key];
+    }
+  }
+  return null;
+};
 export var loadVectorsAsync = /*#__PURE__*/function () {
-  var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(options) {
+  var _ref13 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(options) {
     var _options$isLocalLLM;
-    var isLocalLLM, surface, url, res, buffer, float32, wordIndexPayload, wrappedIndex, wordIndex, nWords, dim, _t, _t2;
+    var isLocalLLM, surface, buffer, float32, wordIndexPayload, wordIndex, nWords, dim, _t;
     return _regeneratorRuntime.wrap(function (_context) {
       while (1) switch (_context.prev = _context.next) {
         case 0:
@@ -709,65 +2291,23 @@ export var loadVectorsAsync = /*#__PURE__*/function () {
           } : {}));
           _context.prev = 2;
           _context.next = 3;
-          return getArtifactUrl(ARTIFACT_NAME.WORD_VECTORS);
+          return fetchAutocompleteArtifactBinary(ARTIFACT_NAME.WORD_VECTORS, 'word_vectors_10k');
         case 3:
-          url = _context.sent;
-          _context.next = 5;
-          break;
-        case 4:
-          _context.prev = 4;
-          _t = _context["catch"](2);
-          vectorsLoadStarted = false;
-          failExp(EXPERIENCE_NAME.LOAD_VECTORS, 'singleton', _objectSpread({
-            isLocalLLM: isLocalLLM,
-            errorType: 'resolve_url'
-          }, surface ? {
-            surface: surface
-          } : {}));
-          // eslint-disable-next-line no-console
-          console.warn('[text-predictor] Failed to resolve vectors URL:', _t);
-          return _context.abrupt("return");
-        case 5:
-          _context.prev = 5;
-          _context.next = 6;
-          return fetch(url);
-        case 6:
-          res = _context.sent;
-          if (res.ok) {
-            _context.next = 7;
-            break;
-          }
-          vectorsLoadStarted = false;
-          failExp(EXPERIENCE_NAME.LOAD_VECTORS, 'singleton', _objectSpread({
-            isLocalLLM: isLocalLLM,
-            status: res.status,
-            errorType: 'http_error'
-          }, surface ? {
-            surface: surface
-          } : {}));
-          // eslint-disable-next-line no-console
-          console.warn("[text-predictor] Failed to load vectors: ".concat(res.status));
-          return _context.abrupt("return");
-        case 7:
-          _context.next = 8;
-          return res.arrayBuffer();
-        case 8:
           buffer = _context.sent;
-          float32 = new Float32Array(buffer); // The word index is published either bare or wrapped as `{ "index": {…} }`
-          // (the wrapper exists so no real entry, e.g. the word "default", can shadow
-          // a bundler-synthesised ESM export). Detect the wrapper by value type, not
-          // by key presence — "index" is itself a plausible vocabulary word, and in a
-          // bare index every value is a number.
-          _context.next = 9;
-          return fetchArtifactJson(ARTIFACT_NAME.WORD_INDEX);
-        case 9:
+          float32 = new Float32Array(buffer);
+          _context.next = 4;
+          return fetchAutocompleteArtifactJson(ARTIFACT_NAME.WORD_INDEX, {
+            summarize: function summarize(payload) {
+              return "".concat(Object.keys(unwrapWordIndex(payload)).length, " entries");
+            },
+            validate: isWordIndexPayload
+          });
+        case 4:
           wordIndexPayload = _context.sent;
-          wrappedIndex = wordIndexPayload === null || wordIndexPayload === void 0 ? void 0 : wordIndexPayload.index;
-          wordIndex = _typeof(wrappedIndex) === 'object' && wrappedIndex !== null ? wrappedIndex : wordIndexPayload !== null && wordIndexPayload !== void 0 ? wordIndexPayload : {};
+          wordIndex = unwrapWordIndex(wordIndexPayload);
           nWords = Object.keys(wordIndex).length;
           if (nWords === 0) {
-            // eslint-disable-next-line no-console
-            console.warn("[text-predictor] ".concat(ARTIFACT_NAME.WORD_INDEX, " was empty \u2014 semantic scoring will be a no-op."));
+            ctcTag('init', '⚠️ word_index_10k.json was empty — semantic scoring will be a no-op', CTC_STYLES.warn);
           }
           dim = float32.length / nWords;
           vectorStore = {
@@ -783,19 +2323,12 @@ export var loadVectorsAsync = /*#__PURE__*/function () {
           }, surface ? {
             surface: surface
           } : {}));
-          if (isAutocompleteDebugEnabled()) {
-            // eslint-disable-next-line no-console
-            console.log('[text-predictor] Vectors loaded:', {
-              wordCount: nWords,
-              dim: dim,
-              sizeBytes: float32.byteLength
-            });
-          }
-          _context.next = 11;
+          ctcTag('init', "vectors loaded: ".concat(nWords, " words \xB7 dim ").concat(dim, " \xB7 ").concat(float32.byteLength, "B"));
+          _context.next = 6;
           break;
-        case 10:
-          _context.prev = 10;
-          _t2 = _context["catch"](5);
+        case 5:
+          _context.prev = 5;
+          _t = _context["catch"](2);
           vectorsLoadStarted = false;
           failExp(EXPERIENCE_NAME.LOAD_VECTORS, 'singleton', _objectSpread({
             isLocalLLM: isLocalLLM,
@@ -803,60 +2336,197 @@ export var loadVectorsAsync = /*#__PURE__*/function () {
           }, surface ? {
             surface: surface
           } : {}));
-          // eslint-disable-next-line no-console
-          console.warn('[text-predictor] Failed to load vectors:', _t2);
-        case 11:
+          ctcTag('init', "\u26A0\uFE0F failed to load vectors: ".concat(String(_t)), CTC_STYLES.bad);
+        case 6:
         case "end":
           return _context.stop();
       }
-    }, _callee, null, [[2, 4], [5, 10]]);
+    }, _callee, null, [[2, 5]]);
   }));
   return function loadVectorsAsync(_x) {
-    return _ref6.apply(this, arguments);
+    return _ref13.apply(this, arguments);
   };
 }();
 export var initVectors = function initVectors(store) {
   vectorStore = store;
 };
+
+/**
+ * Load the producer's `bigrams.json` + `phrases.json` completion-term artifacts
+ * over the TDP-OS gateway and insert them into the phrase trie.
+ *
+ * Each file is fetched independently (`Promise.allSettled`) so a missing or
+ * late-published artifact only skips that term type — word completion and the
+ * other term type are unaffected. Phrase VECTORS are not fetched here: per the
+ * producer's `extend` decision they are appended into the existing
+ * `word-index-10k.json` / `word-vectors-10k.bin`, so `loadVectorsAsync` already
+ * covers them.
+ *
+ * :params:
+ *   options.isLocalLLM: Tags the UFO experience so latency/success feeds the same SLO
+ * :returns:
+ *   A promise that resolves once both fetches have settled
+ */
+export var loadPhraseArtifacts = /*#__PURE__*/function () {
+  var _ref14 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(options) {
+    var _options$isLocalLLM2;
+    var isLocalLLM, loadOne, _yield$Promise$allSet, _yield$Promise$allSet2, bigramsResult, phrasesResult, bigramCount, phraseCount;
+    return _regeneratorRuntime.wrap(function (_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          if (!phrasesLoadStarted) {
+            _context3.next = 1;
+            break;
+          }
+          return _context3.abrupt("return");
+        case 1:
+          phrasesLoadStarted = true;
+          isLocalLLM = (_options$isLocalLLM2 = options === null || options === void 0 ? void 0 : options.isLocalLLM) !== null && _options$isLocalLLM2 !== void 0 ? _options$isLocalLLM2 : false;
+          startExp(EXPERIENCE_NAME.LOAD_PHRASES, 'singleton', {
+            isLocalLLM: isLocalLLM
+          });
+          loadOne = /*#__PURE__*/function () {
+            var _ref15 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(artifactName, termType, label) {
+              var payload, normalized;
+              return _regeneratorRuntime.wrap(function (_context2) {
+                while (1) switch (_context2.prev = _context2.next) {
+                  case 0:
+                    _context2.next = 1;
+                    return fetchAutocompleteArtifactJson(artifactName, {
+                      label: label,
+                      validate: function validate(p) {
+                        return p != null && _typeof(p) === 'object';
+                      }
+                    });
+                  case 1:
+                    payload = _context2.sent;
+                    normalized = normalizePhraseArtifact(payload);
+                    if (normalized) {
+                      _context2.next = 2;
+                      break;
+                    }
+                    throw new Error("[text-predictor] ".concat(label, " payload was not a recognised term-stats map"));
+                  case 2:
+                    return _context2.abrupt("return", initPhrases(normalized, termType));
+                  case 3:
+                  case "end":
+                    return _context2.stop();
+                }
+              }, _callee2);
+            }));
+            return function loadOne(_x3, _x4, _x5) {
+              return _ref15.apply(this, arguments);
+            };
+          }();
+          _context3.next = 2;
+          return Promise.allSettled([loadOne(ARTIFACT_NAME.BIGRAMS, 'bigram', 'bigrams'), loadOne(ARTIFACT_NAME.PHRASES, 'phrase', 'phrases')]);
+        case 2:
+          _yield$Promise$allSet = _context3.sent;
+          _yield$Promise$allSet2 = _slicedToArray(_yield$Promise$allSet, 2);
+          bigramsResult = _yield$Promise$allSet2[0];
+          phrasesResult = _yield$Promise$allSet2[1];
+          bigramCount = bigramsResult.status === 'fulfilled' ? bigramsResult.value : 0;
+          phraseCount = phrasesResult.status === 'fulfilled' ? phrasesResult.value : 0;
+          if (bigramsResult.status === 'rejected') {
+            ctcTag('init', "\u26A0\uFE0F failed to load bigrams.json: ".concat(String(bigramsResult.reason)), CTC_STYLES.warn);
+          }
+          if (phrasesResult.status === 'rejected') {
+            ctcTag('init', "\u26A0\uFE0F failed to load phrases.json: ".concat(String(phrasesResult.reason)), CTC_STYLES.warn);
+          }
+          if (bigramsResult.status === 'fulfilled' || phrasesResult.status === 'fulfilled') {
+            phrasesLoaded = true;
+            succeedExp(EXPERIENCE_NAME.LOAD_PHRASES, 'singleton', {
+              isLocalLLM: isLocalLLM,
+              bigramCount: bigramCount,
+              phraseCount: phraseCount
+            });
+            ctcTag('init', "phrase artifacts loaded: ".concat(bigramCount, " bigrams \xB7 ").concat(phraseCount, " phrases"));
+          } else {
+            // Both failed — e.g. artifacts not published to the tenant manifest yet.
+            // Reset the guard so a later focus/predict can retry once they land.
+            phrasesLoadStarted = false;
+            failExp(EXPERIENCE_NAME.LOAD_PHRASES, 'singleton', {
+              isLocalLLM: isLocalLLM,
+              errorType: 'network'
+            });
+          }
+        case 3:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  }));
+  return function loadPhraseArtifacts(_x2) {
+    return _ref14.apply(this, arguments);
+  };
+}();
 var vocabularyLoadPromise;
 export var loadDefaultVocabulary = function loadDefaultVocabulary(options) {
-  var _options$isLocalLLM2;
+  var _options$isLocalLLM3, _options$source;
   if (isInitialized) {
     return Promise.resolve();
   }
   if (vocabularyLoadPromise) {
     return vocabularyLoadPromise;
   }
-  var isLocalLLM = (_options$isLocalLLM2 = options === null || options === void 0 ? void 0 : options.isLocalLLM) !== null && _options$isLocalLLM2 !== void 0 ? _options$isLocalLLM2 : false;
+  var isLocalLLM = (_options$isLocalLLM3 = options === null || options === void 0 ? void 0 : options.isLocalLLM) !== null && _options$isLocalLLM3 !== void 0 ? _options$isLocalLLM3 : false;
+  var source = (_options$source = options === null || options === void 0 ? void 0 : options.source) !== null && _options$source !== void 0 ? _options$source : 'predict';
   var surface = options === null || options === void 0 ? void 0 : options.surface;
-  vocabularyLoadPromise = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
-    var _yield$Promise$all, _yield$Promise$all2, vocabularyData, l3VocabularyData, terms, _t3;
-    return _regeneratorRuntime.wrap(function (_context2) {
-      while (1) switch (_context2.prev = _context2.next) {
+  vocabularyLoadPromise = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+    var _yield$Promise$all, _yield$Promise$all2, vocabularyData, l3VocabularyData, terms, _t2;
+    return _regeneratorRuntime.wrap(function (_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
         case 0:
           startExp(EXPERIENCE_NAME.LOAD_VOCABULARY, 'singleton', _objectSpread({
             isLocalLLM: isLocalLLM
           }, surface ? {
             surface: surface
           } : {}));
-          _context2.prev = 1;
-          _context2.next = 2;
-          return Promise.all([fetchArtifactJson(ARTIFACT_NAME.VOCABULARY), fetchArtifactJson(ARTIFACT_NAME.L3_VOCABULARY)]);
+          _context4.prev = 1;
+          ctcTag('init', "loading artifacts (trigger: ".concat(source, " \xB7 localLLM: ").concat(isLocalLLM, ")"));
+          if (isAutocompleteDebugVerbose()) {
+            // eslint-disable-next-line no-console
+            console.groupCollapsed('%c[CTC:init]%c artifact manifest', CTC_STYLES.brand, CTC_STYLES.body);
+            // eslint-disable-next-line no-console
+            console.log('Eager:', [ARTIFACT_NAME.VOCABULARY, ARTIFACT_NAME.L3_VOCABULARY, ARTIFACT_NAME.POS_TAGS, ARTIFACT_NAME.GHOST_POS_TAGS, ARTIFACT_NAME.GRAMMAR_TRANSITIONS]);
+            // eslint-disable-next-line no-console
+            console.log('Conditional:', ["".concat(ARTIFACT_NAME.WORD_INDEX, " (only when vectors load; phrase/bigram surfaces share this index)"), "".concat(ARTIFACT_NAME.BIGRAMS, " + ").concat(ARTIFACT_NAME.PHRASES, " (completion-term stats; fire-and-forget)"), "".concat(ARTIFACT_NAME.PHRASE_CONTINUATION_TOKENS, " (local model only; canonical token IDs for the full served union)")]);
+            // eslint-disable-next-line no-console
+            console.groupEnd();
+          }
+          _context4.next = 2;
+          return Promise.all([fetchAutocompleteArtifactJson(ARTIFACT_NAME.VOCABULARY, {
+            summarize: function summarize(payload) {
+              return "".concat(Object.keys(payload.words).length, " words");
+            },
+            validate: isVocabularyJson
+          }), fetchAutocompleteArtifactJson(ARTIFACT_NAME.L3_VOCABULARY, {
+            summarize: function summarize(payload) {
+              return "".concat(payload.length, " words");
+            },
+            validate: isStringArray
+          }),
+          // Awaited alongside the vocabulary so the grammar filter is settled
+          // before the first suggestion can be produced. Without this the
+          // predictor initialises on the smaller vocabulary payload and serves
+          // candidates the filter would have dropped until the grammar lands.
+          // Only settlement is required: a failed load leaves the filter as a
+          // pass-through, which is the same degradation as an absent artifact.
+          loadGrammarDataAsync({
+            isLocalLLM: isLocalLLM,
+            surface: surface
+          }).catch(function (error) {
+            ctcTag('init', "\u26A0\uFE0F grammar data unavailable; filtering skipped: ".concat(String(error)), CTC_STYLES.warn);
+          })]);
         case 2:
-          _yield$Promise$all = _context2.sent;
+          _yield$Promise$all = _context4.sent;
           _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 2);
           vocabularyData = _yield$Promise$all2[0];
           l3VocabularyData = _yield$Promise$all2[1];
-          if (!((vocabularyData === null || vocabularyData === void 0 ? void 0 : vocabularyData.words) == null || !Array.isArray(l3VocabularyData))) {
-            _context2.next = 3;
-            break;
-          }
-          throw new Error("[text-predictor] unexpected vocabulary payload \u2014 " + "".concat(ARTIFACT_NAME.VOCABULARY, " ").concat((vocabularyData === null || vocabularyData === void 0 ? void 0 : vocabularyData.words) == null ? 'is missing its `words` wrapper' : 'is valid', ", ") + "".concat(ARTIFACT_NAME.L3_VOCABULARY, " ").concat(Array.isArray(l3VocabularyData) ? 'is valid' : 'is not an array'));
-        case 3:
-          terms = Object.entries(vocabularyData.words).map(function (_ref8) {
-            var _ref9 = _slicedToArray(_ref8, 2),
-              word = _ref9[0],
-              stats = _ref9[1];
+          terms = Object.entries(vocabularyData.words).map(function (_ref17) {
+            var _ref18 = _slicedToArray(_ref17, 2),
+              word = _ref18[0],
+              stats = _ref18[1];
             return {
               word: word,
               freq: stats.freq,
@@ -870,6 +2540,12 @@ export var loadDefaultVocabulary = function loadDefaultVocabulary(options) {
           initVocabulary({
             terms: terms
           });
+
+          // Phrase/bigram artifacts load independently and must never affect the
+          // word path — fire-and-forget with its own error handling inside.
+          void loadPhraseArtifacts({
+            isLocalLLM: isLocalLLM
+          }).catch(function () {});
           succeedExp(EXPERIENCE_NAME.LOAD_VOCABULARY, 'singleton', _objectSpread({
             isLocalLLM: isLocalLLM,
             l2WordCount: terms.length,
@@ -877,25 +2553,25 @@ export var loadDefaultVocabulary = function loadDefaultVocabulary(options) {
           }, surface ? {
             surface: surface
           } : {}));
-          _context2.next = 5;
+          _context4.next = 4;
           break;
-        case 4:
-          _context2.prev = 4;
-          _t3 = _context2["catch"](1);
+        case 3:
+          _context4.prev = 3;
+          _t2 = _context4["catch"](1);
           failExp(EXPERIENCE_NAME.LOAD_VOCABULARY, 'singleton', _objectSpread({
             isLocalLLM: isLocalLLM,
-            errorType: 'load_error'
+            errorType: 'parse_error'
           }, surface ? {
             surface: surface
           } : {}));
           // Allow a later call to retry the load rather than caching the failure.
           vocabularyLoadPromise = undefined;
-          throw _t3;
-        case 5:
+          throw _t2;
+        case 4:
         case "end":
-          return _context2.stop();
+          return _context4.stop();
       }
-    }, _callee2, null, [[1, 4]]);
+    }, _callee4, null, [[1, 3]]);
   }))();
   return vocabularyLoadPromise;
 };