@remnic/core 9.63.8 → 9.63.10

package/src/entity-retrieval-i18n.ts

@@ -0,0 +1,161 @@
+import { normalizeEntityText } from "./entity-schema.js";
+
+/**
+ * Non-English query-mode cues for entity retrieval (#2193).
+ *
+ * #2161 made explicit entity mentions language-independent, but follow-up /
+ * pronoun coreference and timeline phrasing still classify through English
+ * word lists in `detectEntityQueryMode`. These cue tables plus the structural
+ * follow-up signal below close that gap without building a full coreference
+ * engine: the structural layer covers zero-pronoun scripts (Japanese,
+ * Chinese, Korean — languages that omit the subject entirely and can never
+ * trip a pronoun word list), and the tables add precision for other scripts,
+ * including Latin-script languages whose pronoun follow-ups carry their
+ * pronoun explicitly. Latin-script queries never use the structural layer:
+ * their generic technical questions ("what does this error mean?") are
+ * indistinguishable from subject-less follow-ups by shape alone.
+ */
+
+export type EntityQueryMode = "direct" | "timeline" | "follow_up";
+
+/** Shared short-question bound. Whitespace tokens are a poor length proxy
+ * for unspaced scripts, so bound graphemes too (48 graphemes ≈ 8 words). */
+const FOLLOW_UP_MAX_TOKENS = 8;
+const FOLLOW_UP_MAX_GRAPHEMES = 48;
+
+/** Latin letters mark a script with explicit pronouns; structural fallback
+ * never applies there (English "what does this error mean?" and its
+ * relatives keep the technical-question guard in detectEntityQueryMode). */
+const LATIN_LETTER_RE = /\p{Script=Latin}/u;
+
+ /** Latin / question marks: ASCII `?`, fullwidth `？` (CJK), Arabic `؟`. */
+ const QUESTION_MARK_RE = /[?？؟]/;
+
+/**
+ * CJK cues and normalized multi-word phrases match by containment; single
+ * Latin/Cyrillic/Arabic words match with a script-agnostic letter boundary
+ * so `él` never matches `el` and `il` never matches `famille`.
+ */
+const FOLLOW_UP_CONTAINS_CUES = [
+  // ja
+  "彼", "彼女", "あの人", "その人", "それで", "ちなみに",
+  // zh (simplified + traditional)
+  "他", "她", "它", "他们", "她们", "他們", "她們", "然后呢", "然後呢",
+  // ko
+  "그녀", "그 사람", "걔",
+] as const;
+
+const FOLLOW_UP_WORD_CUES = [
+  // es
+  "él", "ella", "ellos", "ellas",
+  // fr
+  "elle", "eux",
+  // de
+  "sie",
+  // pt
+  "ele", "ela",
+  // it
+  "lui", "lei",
+  // ru
+  "он", "она", "они",
+  // ar
+  "هو", "هي", "هم",
+] as const;
+
+const TIMELINE_CONTAINS_CUES = [
+  // ja
+  "最近", "その後", "どうなった", "何があった",
+  // zh (simplified + traditional)
+  "怎么样了", "怎麼樣了", "后来", "後來", "最新", "近况", "近況", "什么情况", "什麼情況",
+  // ko
+  "요즘", "요새", "최근",
+  // multi-word phrases, already in normalized form (punctuation → space)
+  "qué hay de nuevo", "qué pasó con", "quoi de neuf", "что нового",
+  "что случилось", "ما الجديد", "ماذا حدث", "was gibt s neues",
+] as const;
+
+function wordCueRegex(cues: readonly string[]): RegExp {
+  const alternation = cues
+    .map((cue) => cue.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+    .join("|");
+  return new RegExp(`(?<![\\p{L}\\p{N}])(?:${alternation})(?![\\p{L}\\p{N}])`, "u");
+}
+
+const FOLLOW_UP_WORD_RE = wordCueRegex(FOLLOW_UP_WORD_CUES);
+
+function isShortFollowUpShaped(normalized: string): boolean {
+  if (!normalized) return false;
+  const tokens = normalized.split(/\s+/).filter(Boolean);
+  if (tokens.length > FOLLOW_UP_MAX_TOKENS) return false;
+  return Array.from(normalized).length <= FOLLOW_UP_MAX_GRAPHEMES;
+}
+
+/**
+ * Classify already-normalized non-English queries. Returns null when no
+ * table cue matches; callers keep their English rules untouched.
+ */
+export function detectNonEnglishEntityQueryMode(normalizedQuery: string): EntityQueryMode | null {
+  if (!normalizedQuery) return null;
+  if (
+    isShortFollowUpShaped(normalizedQuery)
+    && (
+      FOLLOW_UP_CONTAINS_CUES.some((cue) => normalizedQuery.includes(cue))
+      || FOLLOW_UP_WORD_RE.test(normalizedQuery)
+    )
+  ) {
+    return "follow_up";
+  }
+  if (TIMELINE_CONTAINS_CUES.some((cue) => normalizedQuery.includes(cue))) {
+    return "timeline";
+  }
+  return null;
+}
+
+/**
+ * Structural follow-up signal, independent of pronoun vocabulary: a short
+ * question carrying no entity name, asked while recent dialogue exists, is a
+ * coreference cue in zero-pronoun scripts (Latin-script queries are excluded
+ * above — their follow-ups carry pronouns that the cue tables and English
+ * rules classify). Recent-turn candidate resolution (and its empty result →
+ * section absent) remains the real gate, so this only routes the query into
+ * the follow-up path; it never invents an entity.
+ */
+export function isStructuralEntityFollowUpQuery(query: string, hasRecentDialogue: boolean): boolean {
+  if (!hasRecentDialogue) return false;
+  if (LATIN_LETTER_RE.test(query)) return false;
+  const normalized = normalizeEntityText(query);
+  return isShortFollowUpShaped(normalized) && QUESTION_MARK_RE.test(query);
+}
+
+const ENTITY_PRONOUN_RE = /\b(he|him|his|she|her|they|them|their|it|its)\b/i;
+
+export 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 detectNonEnglishEntityQueryMode(normalized);
+}
+

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/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)];
 }
 
 /**