@remnic/core 9.63.9 → 9.63.11

package/src/entity-retrieval.ts

@@ -10,6 +10,11 @@ import { normalizeEntityText, resolveRequestedEntitySectionKeys } from "./entity
 import type { EntityStructuredSection, MemoryFile, PluginConfig, TranscriptEntry } from "./types.js";
 import { truncateGraphemeSafe } from "./whitespace.js";
 import { containsPhrase } from "./entity-retrieval-boundaries.js";
+import {
+  detectEntityQueryMode,
+  isStructuralEntityFollowUpQuery,
+  type EntityQueryMode,
+} from "./entity-retrieval-i18n.js";
 import { buildOriginStructuredSections, sanitizeOriginatedFacts, type EntityOriginStructuredSection } from "./entity-origin-fields.js";
 import {
   checkEntityRecallAbort,
@@ -21,10 +26,8 @@ const ENTITY_INDEX_VERSION = 3;
 const RECENT_TRANSCRIPT_LOOKBACK_HOURS = 24;
 const INSTRUCTION_LIKE_RE = /\b(always|never|must|should|remember to|do not|don't|process|workflow|template|checklist|instruction)\b/i;
 const METADATA_WRAPPER_RE = /^(source|context|metadata|notes?):/i;
-const ENTITY_PRONOUN_RE = /\b(he|him|his|she|her|they|them|their|it|its)\b/i;
 const BELIEF_LEDGER_SECTION_KEY = "belief_ledger";
 const BELIEF_LEDGER_FACT_RE = /^claim=([^;]+);\s*status=([^;]+);\s*updatedAt=([^;]+);\s*(.+)$/;
-type EntityQueryMode = "direct" | "timeline" | "follow_up";
 type EntityMentionIndexEntry = {
   canonicalId: string;
   name: string;
@@ -171,35 +174,6 @@ function relationLine(entry: EntityMentionIndexEntry, relationship: { target: st
   if (normalizedLabel.length === 0) return `${entry.name} is connected to ${relationship.target}`;
   return `${entry.name} ${normalizedLabel} ${relationship.target}`;
 }
-function detectEntityQueryMode(query: string): EntityQueryMode | null {
-  const normalized = normalizeEntityText(query);
-  if (!normalized) return null;
-  if (
-    /^(what about|and what about|how about|what happened (with|to) (he|him|his|she|her|they|them|their|it|its)|did (he|she|they|it)|is (he|she|they|it)|was (he|she|they|it))\b/.test(normalized)
-  ) {
-    return "follow_up";
-  }
-  if (
-    /^(who is|who s|what do we know about|what does|tell me about|what can you tell me about|what s new with|what happened with|what happened to|status of|where is|how is)\b/.test(normalized)
-  ) {
-    if (/^what does\b/.test(normalized)) {
-      if (/^what does (?:this|that|it|the|a|an|my|our|your|their)\b/.test(normalized)) {
-        return null;
-      }
-      if (
-        /^what does [a-z0-9-]+ (?:error|warning|exception|failure|stack|trace|code|message|log)\b/.test(normalized)
-        && /\b(mean|means|indicate|indicates|imply|implies)\b/.test(normalized)
-      ) {
-        return null;
-      }
-    }
-    return /what happened|what s new|status of|how is|where is/.test(normalized) ? "timeline" : "direct";
-  }
-  if (ENTITY_PRONOUN_RE.test(normalized) && normalized.split(/\s+/).length <= 8) {
-    return "follow_up";
-  }
-  return null;
-}
 function scoreAliasMatch(query: string, alias: string): number {
   const normalizedQuery = normalizeEntityText(query);
   const normalizedAlias = normalizeEntityText(alias);
@@ -1061,7 +1035,18 @@ export async function buildEntityRecallSection(options: BuildEntityRecallSection
   // during a scan is observed here (issue #2291).
   checkEntityRecallAbort(options.abortSignal);
   const prefixedMode = detectEntityQueryMode(options.query);
-  const persistedIndex = prefixedMode
+  // #2193: in zero-pronoun scripts a short question with no entity name
+  // never trips a pronoun word list, so the structural signal routes it
+  // into the same coreference path as an English "what about him?".
+  // Latin-script queries stay on the cue tables / English rules so the
+  // generic technical-question guard keeps working. Resolution gates.
+  const structuralFollowUp = prefixedMode === null
+    && isStructuralEntityFollowUpQuery(
+      options.query,
+      options.recentTurns > 0 && options.transcriptEntries.length > 0,
+    );
+  const earlyMode = prefixedMode ?? (structuralFollowUp ? "follow_up" : null);
+  const persistedIndex = earlyMode
     ? null
     : await readCurrentPersistedEntityIndex(
       options.storage,
@@ -1072,7 +1057,7 @@ export async function buildEntityRecallSection(options: BuildEntityRecallSection
   checkEntityRecallAbort(options.abortSignal);
   let nativeChunks: NativeKnowledgeChunk[] | undefined;
   if (
-    !prefixedMode &&
+    !earlyMode &&
     persistedIndex &&
     resolveLanguageIndependentExplicitCandidates(persistedIndex, options.query).length === 0
   ) {
@@ -1129,7 +1114,22 @@ export async function buildEntityRecallSection(options: BuildEntityRecallSection
   const queryCandidates = prefixedMode
     ? explicitCandidates
     : resolveLanguageIndependentExplicitCandidates(index, options.query);
-  const mode = prefixedMode ?? (queryCandidates.length > 0 ? "direct" : null);
+  if (
+    queryCandidates.length === 0
+    && /^what does (?:this|that|it|the|a|an|my|our|your|their)\b/i.test(normalizeEntityText(options.query))
+  ) {
+    return entityRecallSectionAbsent(options.abortSignal);
+  }
+
+  // Explicit mentions keep #2161 behavior (direct mode) even when the
+  // structural follow-up signal also fired; only name-less short questions
+  // fall through to coreference.
+  const mode = prefixedMode
+    ?? (queryCandidates.length > 0
+      ? "direct"
+      : structuralFollowUp
+        ? "follow_up"
+        : null);
   if (!mode) return entityRecallSectionAbsent(options.abortSignal);
 
   const candidates = queryCandidates.length > 0

package/src/extraction-source-grounding-helpers.ts

@@ -334,9 +334,9 @@ export interface GroundingLexeme {
 }
 
 export function groundingLexemes(text: string): GroundingLexeme[] {
-  const rawTokens = text.normalize("NFKC").match(
+  const rawTokens = (text.normalize("NFKC").match(
     /[\p{L}\p{N}]+(?:['’][\p{L}\p{N}]+)?(?:\+\+[\p{L}\p{N}]*|#[\p{L}\p{N}]*)?/gu,
-  ) ?? [];
+  ) ?? []).flatMap(splitSpacelessScriptToken);
   const tokens = rawTokens.map((rawToken) =>
     rawToken.replaceAll("’", "'").toLocaleLowerCase());
   let predicateIndex = tokens.findIndex((token, index) => {
@@ -500,6 +500,116 @@ export function tokenize(text: string): Set<string> {
   return tokens;
 }
 
+const SPACELESS_SCRIPT_CHARACTER_PATTERN = new RegExp(
+  "[\\p{Script=Han}\\p{Script=Hiragana}\\p{Script=Katakana}\\p{Script=Hangul}"
+    + "\\p{Script=Thai}\\p{Script=Lao}\\p{Script=Khmer}\\p{Script=Myanmar}]",
+  "u",
+);
+const SPACELESS_SCRIPT_LCS_SOURCE_LIMIT = 4096;
+
+function containsSpacelessScriptCharacter(text: string): boolean {
+  return SPACELESS_SCRIPT_CHARACTER_PATTERN.test(text);
+}
+
+/**
+ * Scripts without word separators (CJK, Hangul, Thai, ...) must not become one
+ * whitespace-delimited token: a paraphrase never matches a whole-run token, so
+ * grounded CJK facts and entity names were dropped. Split those runs into
+ * per-character lexemes so contiguous-token matching behaves as substring
+ * matching for these scripts.
+ */
+function splitSpacelessScriptToken(rawToken: string): string[] {
+  if (!containsSpacelessScriptCharacter(rawToken)) return [rawToken];
+  const parts: string[] = [];
+  let otherScriptRun = "";
+  for (const character of rawToken) {
+    if (containsSpacelessScriptCharacter(character)) {
+      if (otherScriptRun.length > 0) {
+        parts.push(otherScriptRun);
+        otherScriptRun = "";
+      }
+      parts.push(character);
+    } else {
+      otherScriptRun += character;
+    }
+  }
+  if (otherScriptRun.length > 0) parts.push(otherScriptRun);
+  return parts;
+}
+
+function spacelessScriptCharacterSequence(text: string): string[] {
+  const characters: string[] = [];
+  for (const character of text.normalize("NFKC")) {
+    if (containsSpacelessScriptCharacter(character)) characters.push(character);
+  }
+  return characters;
+}
+
+function spacelessScriptCharacterNgrams(text: string): Set<string> {
+  const grams = new Set<string>();
+  let previousCharacter = "";
+  for (const character of spacelessScriptCharacterSequence(text)) {
+    if (previousCharacter !== "") grams.add(previousCharacter + character);
+    previousCharacter = character;
+  }
+  return grams;
+}
+
+function longestCommonSubstringLength(
+  left: ReadonlyArray<string>,
+  right: ReadonlyArray<string>,
+): number {
+  if (left.length === 0 || right.length === 0) return 0;
+  let longest = 0;
+  let previousRow = new Array<number>(right.length).fill(0);
+  for (const leftCharacter of left) {
+    const currentRow = new Array<number>(right.length).fill(0);
+    for (let index = 0; index < right.length; index += 1) {
+      if (leftCharacter !== right[index]) continue;
+      currentRow[index] = (index > 0 ? previousRow[index - 1] : 0) + 1;
+      if (currentRow[index] > longest) longest = currentRow[index];
+    }
+    previousRow = currentRow;
+  }
+  return longest;
+}
+
+/**
+ * Script-aware grounding score for candidates written in scripts without word
+ * separators. Returns null when the candidate has no such characters, so
+ * whitespace-delimited candidates keep the default scorer. The longest-common-
+ * span gate rejects topical overlap that shares mostly function characters.
+ * ponytail: n-grams and the common-span gate ignore argument order; swap in a
+ * segmentation-aware matcher if CJK role confusion surfaces.
+ */
+export function spacelessScriptGroundedTokenScore(candidate: string, source: string): number | null {
+  const candidateGrams = spacelessScriptCharacterNgrams(candidate);
+  if (candidateGrams.size === 0) return null;
+  const sourceGrams = spacelessScriptCharacterNgrams(source);
+  let sharedGrams = 0;
+  for (const gram of candidateGrams) {
+    if (sourceGrams.has(gram)) sharedGrams += 1;
+  }
+  if (sharedGrams < GROUNDING_MIN_SHARED_TOKENS) return 0;
+  const coverage = sharedGrams / candidateGrams.size;
+  if (coverage < GROUNDING_MIN_COVERAGE) return 0;
+  const candidateCharacters = spacelessScriptCharacterSequence(candidate);
+  const sourceCharacters = spacelessScriptCharacterSequence(source);
+  if (sourceCharacters.length <= SPACELESS_SCRIPT_LCS_SOURCE_LIMIT) {
+    const anchoredFraction = longestCommonSubstringLength(candidateCharacters, sourceCharacters)
+      / candidateCharacters.length;
+    if (anchoredFraction < GROUNDING_MIN_COVERAGE) return 0;
+  }
+  const sourceTokens = tokenize(source);
+  for (const token of tokenize(candidate)) {
+    if (containsSpacelessScriptCharacter(token)) continue;
+    if (![...sourceTokens].some((sourceToken) => areGroundingTokensCompatible(token, sourceToken))) {
+      return 0;
+    }
+  }
+  return coverage;
+}
+
 export function normalizeForExactMatch(text: string): string {
   return text.normalize("NFKC").toLocaleLowerCase().replace(/\s+/gu, " ").trim();
 }

package/src/extraction-source-grounding-rules.ts

@@ -14,12 +14,12 @@ import {
   groundingTokenSequence,
   hasContradictoryPolarity,
   hasExplicitRoleSubjectToken,
-  isAttachedNegatedAuxiliary,
   isInterrogativeSourceSentence,
   normalizeForExactMatch,
   normalizedGroundingAlignmentTokenSequence,
   normalizedGroundingTokenSequence,
   sourceSentences,
+  spacelessScriptGroundedTokenScore,
   splitGroundingClauses,
   stemToken,
   tokenize,
@@ -229,6 +229,8 @@ function groundedTokenScore(
   requireAlignedArguments = true,
   requireAllCandidateTokensGrounded = true,
 ): number {
+  const scriptAwareScore = spacelessScriptGroundedTokenScore(candidate, source);
+  if (scriptAwareScore !== null) return scriptAwareScore;
   const candidateTokens = tokenize(candidate);
   if (candidateTokens.size === 0) return 0;
   const sourceTokens = tokenize(source);

package/src/extraction-source-grounding.test.ts

@@ -2665,3 +2665,55 @@ test("grounding preserves plural identifiers after a proper-name copular subject
     assert.deepEqual(result.facts, []);
   }
 });
+
+const JAPANESE_OBSERVED_TURN = {
+  role: "user" as const,
+  content: "田中さんは東京に住んでいます。毎日電車で会社に行きます。",
+  timestamp: "2026-07-25T12:00:00.000Z",
+};
+
+test("script-aware grounding keeps CJK paraphrased facts and embedded entity names", async () => {
+  const engine = fixtureEngine({
+    localLlmEnabled: true,
+    localLlmModel: "fixture-local",
+    localLlmFallback: false,
+  });
+  Object.assign(engine, {
+    localLlm: {
+      async chatCompletion() {
+        return {
+          content: JSON.stringify({
+            facts: [
+              {
+                category: "fact",
+                content: "田中さんは東京に住んでいる",
+                confidence: 0.9,
+                tags: [],
+              },
+              {
+                category: "fact",
+                content: "田中さんは大阪に住んでいる",
+                confidence: 0.9,
+                tags: [],
+              },
+            ],
+            profileUpdates: [],
+            entities: [{
+              name: "田中",
+              type: "person",
+              facts: ["東京に住んでいる"],
+            }],
+            questions: [],
+          }),
+        };
+      },
+    },
+  });
+
+  const result = await engine.extract([JAPANESE_OBSERVED_TURN]);
+
+  assert.deepEqual(result.facts.map((fact) => fact.content), ["田中さんは東京に住んでいる"]);
+  assert.equal(result.entities.length, 1);
+  assert.equal(result.entities[0]?.name, "田中");
+  assert.deepEqual(result.entities[0]?.facts, ["東京に住んでいる"]);
+});

package/src/importance.ts

@@ -7,6 +7,7 @@
  */
 
 import type { ImportanceLevel, ImportanceScore, MemoryCategory, MemoryFile } from "./types.js";
+import { cjkBigrams, hasLatinWord, informationalLength } from "./utils/script-aware-text.js";
 
 // ---------------------------------------------------------------------------
 // Marker patterns for each tier
@@ -48,18 +49,6 @@ const HIGH_PATTERNS = [
   /\b(scheduled|appointment|meeting|call)\b/i,
 ];
 
-/** Normal importance markers (0.4-0.7) */
-const NORMAL_PATTERNS = [
-  // Factual content
-  /\b(is|are|was|were|has|have|does|do)\b/i,
-  /\b(because|since|therefore|thus|so)\b/i,
-  // Emotional content
-  /\b(happy|sad|frustrated|excited|worried|anxious)\b/i,
-  /\b(feel|feeling|felt)\b/i,
-  // Technical details
-  /\b(version|api|endpoint|database|server|config)\b/i,
-  /\b(function|class|method|variable|parameter)\b/i,
-];
 
 /** Low importance markers (0.2-0.4) */
 const LOW_PATTERNS = [
@@ -82,8 +71,6 @@ const TRIVIAL_PATTERNS = [
   /^(bye|goodbye|later|see ya|ttyl)[.!]?\s*$/i,
   /^(lol|haha|hehe|lmao|rofl)[.!]?\s*$/i,
   /^(hmm+|uhh*|ahh*|err*|umm*)[.!]?\s*$/i,
-  // Very short content
-  /^.{1,10}$/,
 ];
 
 // ---------------------------------------------------------------------------
@@ -134,16 +121,20 @@ const STOP_WORDS = new Set([
  * Returns top N keywords sorted by relevance.
  */
 function extractKeywords(content: string, maxKeywords: number = 5): string[] {
-  // Tokenize and normalize
-  const words = content
-    .toLowerCase()
-    .replace(/[^a-z0-9\s-]/g, " ")
-    .split(/\s+/)
-    .filter((w) => w.length >= 3 && !STOP_WORDS.has(w));
+  // Latin words plus CJK bigrams, so non-Latin content still yields
+  // keywords (pure-CJK prose returned none before #2192).
+  const candidates = [
+    ...content
+      .toLowerCase()
+      .replace(/[^a-z0-9\s-]/g, " ")
+      .split(/\s+/)
+      .filter((w) => w.length >= 3 && !STOP_WORDS.has(w)),
+    ...cjkBigrams(content),
+  ];
 
   // Count frequencies
   const freq = new Map<string, number>();
-  for (const word of words) {
+  for (const word of candidates) {
     freq.set(word, (freq.get(word) ?? 0) + 1);
   }
 
@@ -170,7 +161,6 @@ export function scoreImportance(
   const reasons: string[] = [];
   let score = 0.5; // Start at normal baseline
 
-  const lowerContent = content.toLowerCase();
   const contentLength = content.length;
 
   // Check for trivial content first (short-circuit)
@@ -185,6 +175,26 @@ export function scoreImportance(
     }
   }
 
+  // Very short content. informationalLength weights CJK/Hangul 3:1, so a
+  // dense non-Latin sentence ("予約しました") is not trivial for being
+  // under 10 raw characters while its English equivalent is not (#2192).
+  const weightedLength = informationalLength(content);
+  if (weightedLength >= 1 && weightedLength <= 10) {
+    return {
+      score: 0.1,
+      level: "trivial",
+      reasons: ["Trivial content (greeting, filler, or very short)"],
+      keywords: [],
+    };
+  }
+
+  // Documented non-Latin fallback (#2192): the English keyword tiers below
+  // cannot fire without Latin words, so the score rests on the 0.5 baseline
+  // plus script-agnostic signals (category boost, length, digits, tags).
+  if (!hasLatinWord(content)) {
+    reasons.push("Non-Latin script: keyword tiers not applicable; script-agnostic signals only");
+  }
+
   // Check critical patterns
   for (const pattern of CRITICAL_PATTERNS) {
     if (pattern.test(content)) {

package/src/recall-disclosure.test.ts

@@ -191,7 +191,7 @@ test("MCP engram.recall rejects non-string disclosure with a structured error",
   const result = (response as { result?: { isError?: boolean; content?: Array<{ text?: string }> } } | undefined)?.result;
   assert.strictEqual(result?.isError, true);
   const text = result?.content?.[0]?.text ?? "";
-  assert.match(text, /disclosure must be a string/i);
+  assert.match(text, /disclosure/i);
 });
 
 test("MCP engram.recall treats explicit `null` disclosure as absent (service applies default)", async () => {

package/src/taxonomy/resolver.ts

@@ -7,6 +7,7 @@
 
 import type { MemoryCategory } from "../types.js";
 import type { ResolverDecision, Taxonomy, TaxonomyCategory } from "./types.js";
+import { cjkBigrams } from "../utils/script-aware-text.js";
 
 const DEFAULT_CATEGORY_ID = "facts";
 
@@ -148,13 +149,12 @@ function computeKeywordScoreForTokens(contentTokens: Set<string>, cat: TaxonomyC
 }
 
 function tokenizeKeywordText(value: string): Set<string> {
-  return new Set(
-    value
-      .toLowerCase()
-      .split(/[^a-z0-9]+/)
-      .map((word) => word.trim())
-      .filter((word) => word.length >= 3 && !TAXONOMY_KEYWORD_STOPWORDS.has(word)),
-  );
+  // CJK bigrams tokenize BOTH sides (content and filing rules), so a
+  // taxonomy written in a CJK language matches CJK content; Latin-only
+  // taxonomies see no change (issue #2192).
+  const latin = (value.toLowerCase().match(/[a-z0-9]+/g) ?? [])
+    .filter((word) => word.length >= 3 && !TAXONOMY_KEYWORD_STOPWORDS.has(word));
+  return new Set([...latin, ...cjkBigrams(value)]);
 }
 
 function selectFallbackCategory(

package/src/topics.ts

@@ -6,6 +6,7 @@
  */
 
 import type { MemoryFile, TopicScore } from "./types.js";
+import { cjkBigrams } from "./utils/script-aware-text.js";
 
 /** Stop words to exclude from topic extraction */
 const STOP_WORDS = new Set([
@@ -28,14 +29,16 @@ const STOP_WORDS = new Set([
 
 /**
  * Extract terms from content.
- * Returns normalized lowercase terms >= 3 chars.
+ * Returns normalized lowercase terms >= 3 chars, plus CJK bigrams so
+ * non-Latin memories contribute topics instead of none (issue #2192).
  */
 function extractTerms(content: string): string[] {
-  return content
+  const latin = content
     .toLowerCase()
     .replace(/[^a-z0-9\s-]/g, " ")
     .split(/\s+/)
     .filter((w) => w.length >= 3 && !STOP_WORDS.has(w));
+  return [...latin, ...cjkBigrams(content)];
 }
 
 /**

package/src/utils/script-aware-text.ts

@@ -0,0 +1,52 @@
+/**
+ * Script-aware text primitives for write-path classifiers (issue #2192).
+ *
+ * The local classifiers (importance, topics, taxonomy) grew around English
+ * keyword regexes and Latin-oriented tokenizers. Non-Latin prose matched no
+ * tier and lost every token: a Japanese sentence as dense as a full English
+ * clause was scored by raw character count and filed with zero keyword
+ * overlap. These helpers provide script-agnostic signals — weighted length,
+ * Latin-word detection, CJK bigram tokenization — without language detection.
+ */
+
+/** CJK + Hangul: kana (incl. halfwidth), Hangul jamo/syllables, ext A, unified + compat ideographs, ext B. */
+const CJK_CHAR =
+  /[\u3040-\u30ff\u3130-\u318f\u3400-\u4dbf\u4e00-\u9fff\uac00-\ud7af\uf900-\ufaff\uff66-\uff9f\u{20000}-\u{2a6df}]/u;
+
+const CJK_RUN =
+  /[\u3040-\u30ff\u3130-\u318f\u3400-\u4dbf\u4e00-\u9fff\uac00-\ud7af\uf900-\ufaff\uff66-\uff9f\u{20000}-\u{2a6df}]+/gu;
+
+/** True when the text contains a Latin word of two or more letters. */
+export function hasLatinWord(text: string): boolean {
+  return /[a-z]{2,}/i.test(text);
+}
+
+/**
+ * Length in Latin-equivalent characters: every code point counts 1,
+ * CJK/Hangul code points count 3. One han/kana glyph typically carries a
+ * whole Latin word of information ("予約しました" ≈ "made a reservation"),
+ * so length cutoffs calibrated on English must weight dense scripts up, or
+ * short non-Latin sentences are systematically dumped into trivial buckets.
+ */
+export function informationalLength(text: string): number {
+  let weight = 0;
+  for (const ch of text) {
+    weight += CJK_CHAR.test(ch) ? 3 : 1;
+  }
+  return weight;
+}
+
+/**
+ * Sliding bigrams over contiguous CJK runs — the standard script-agnostic
+ * substitute for word tokenization in unsegmented scripts. Runs shorter
+ * than two characters yield nothing (a lone glyph is too generic a token).
+ */
+export function cjkBigrams(text: string): string[] {
+  const bigrams: string[] = [];
+  for (const run of text.match(CJK_RUN) ?? []) {
+    for (let i = 0; i + 1 < run.length; i++) {
+      bigrams.push(run.slice(i, i + 2));
+    }
+  }
+  return bigrams;
+}

package/src/write-classifiers-cjk.test.ts

@@ -0,0 +1,115 @@
+/**
+ * Issue #2192: write-path classifiers must not dump non-English content
+ * into the lowest importance/taxonomy bucket merely for lacking English
+ * tokens. Script-agnostic signals (weighted length, CJK bigrams) carry the
+ * decision instead of English keywords.
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { scoreImportance } from "./importance.js";
+import { extractTopics } from "./topics.js";
+import { DEFAULT_TAXONOMY } from "./taxonomy/default-taxonomy.js";
+import { resolveCategory } from "./taxonomy/resolver.js";
+import type { Taxonomy } from "./taxonomy/types.js";
+import type { MemoryFile, MemoryFrontmatter } from "./types.js";
+
+function makeMemory(id: string, content: string): MemoryFile {
+  const frontmatter: MemoryFrontmatter = {
+    id,
+    category: "fact",
+    created: "2026-08-17T00:00:00.000Z",
+    updated: "2026-08-17T00:00:00.000Z",
+    source: "extraction",
+    confidence: 0.8,
+    confidenceTier: "explicit",
+    tags: [],
+  };
+  return { path: `/memories/facts/2026-08-17/${id}.md`, frontmatter, content };
+}
+
+test("importance: dense Japanese/Chinese facts stay out of the trivial/low buckets", () => {
+  // 12 CJK chars ≈ a full English clause ("I will move to Tokyo next month").
+  // Before #2192 this matched the raw `^.{1,10}$` short-content rule and was
+  // scored trivial — dropping it at the write gate.
+  const japanese = scoreImportance("来月、東京に引っ越します。", "commitment");
+  assert.ok(
+    japanese.score >= 0.4,
+    `Japanese commitment scored ${japanese.score} (${japanese.level})`,
+  );
+  assert.notEqual(japanese.level, "trivial");
+  assert.notEqual(japanese.level, "low");
+
+  const chinese = scoreImportance("会议定在周五下午两点，请准时参加。", "fact");
+  assert.ok(
+    chinese.score >= 0.4,
+    `Chinese meeting fact scored ${chinese.score} (${chinese.level})`,
+  );
+  assert.notEqual(chinese.level, "trivial");
+  assert.notEqual(chinese.level, "low");
+
+  // Keywords must not be empty for non-Latin content (CJK bigram fallback).
+  assert.ok(
+    japanese.keywords.length > 0,
+    `expected CJK bigram keywords, got ${JSON.stringify(japanese.keywords)}`,
+  );
+});
+
+test("importance: genuinely trivial CJK interjections stay trivial", () => {
+  // "はい" ≈ "yes" — 2 glyphs, weighted length 6, still under the cutoff.
+  assert.equal(scoreImportance("はい", "fact").level, "trivial");
+  assert.equal(scoreImportance("嗯", "fact").level, "trivial");
+});
+
+test("taxonomy: CJK filing rules match CJK content instead of the fallback pick", () => {
+  const taxonomy: Taxonomy = {
+    version: 1,
+    categories: [
+      {
+        id: "paris-notes",
+        name: "Paris Notes",
+        description: "Statements about Paris",
+        filingRules: ["paris seine arrondissement"],
+        // Lower priority wins the pre-fix keyword-less tie-break, so this
+        // fixture fails unless CJK content actually matches CJK filing rules.
+        priority: 10,
+        memoryCategories: ["fact"],
+      },
+      {
+        id: "tokyo-notes",
+        name: "Tokyo Notes",
+        description: "東京に関する事実",
+        filingRules: ["東京 についての記録"],
+        priority: 40,
+        memoryCategories: ["fact"],
+      },
+    ],
+  };
+
+  const decision = resolveCategory("東京に住んでいます。", "fact", taxonomy);
+  assert.equal(decision.categoryId, "tokyo-notes");
+  assert.ok(decision.confidence >= 0.9, `confidence ${decision.confidence}`);
+});
+
+test("taxonomy: default taxonomy resolution is unchanged for non-Latin facts", () => {
+  const decision = resolveCategory("会議は金曜日の午後です。", "fact", DEFAULT_TAXONOMY);
+  assert.equal(decision.categoryId, "facts");
+  assert.equal(decision.confidence, 1.0);
+});
+
+test("topics: CJK memories contribute topics via bigrams", () => {
+  const topics = extractTopics(
+    [
+      makeMemory(
+        "fact-cjk",
+        "東京に住んでいます。東京の会社で働いています。",
+      ),
+      makeMemory("fact-en", "Deployed the api server to production."),
+    ],
+    20,
+  );
+
+  const tokyo = topics.find((t) => t.term === "東京");
+  assert.ok(tokyo, `expected 東京 in topics: ${JSON.stringify(topics)}`);
+  assert.ok(tokyo.count >= 2, `expected 東京 twice, got ${tokyo.count}`);
+});