@remnic/core 9.63.0 → 9.63.2

package/src/recall-planner-i18n.ts

@@ -0,0 +1,193 @@
+/**
+ * Per-script closed-class cue tables and script-agnostic signal helpers
+ * shared by the recall planner heuristics (issue #2191).
+ *
+ * English keyword regexes stay in their consumers. These tables seed the
+ * top ~10 languages so non-English prompts route to the same recall modes
+ * as their English equivalents. Substring cues are curated so pure-ASCII
+ * entries are multi-word phrases (or non-English single words) that cannot
+ * occur in English text — the English corpus behavior is unchanged.
+ */
+
+const ASCII_CHARS = /[\u0000-\u007f]/g;
+const LETTER_RE = /\p{L}/u;
+const WORDISH_RE = /[\p{L}\p{N}]/u;
+const QUESTION_MARK_END_RE = /[?？؟]$/u;
+const COLON_TERMINATED_RE = /[:：]\s*$/u;
+
+/** True when the text contains a letter outside ASCII — the English keyword
+ * tables cannot be assumed to apply. */
+export function hasNonAsciiLetter(text: string): boolean {
+  return LETTER_RE.test(text.replace(ASCII_CHARS, ""));
+}
+
+/** Strip trailing punctuation/symbols/emojis (Unicode-aware) so exact-match
+ * ack detection works for "はい。", "merci !", "شكرا" etc. */
+export function stripTrailingRecallNoise(text: string): string {
+  let candidate = text;
+  while (candidate.length > 0) {
+    const last = candidate.at(-1) ?? "";
+    if (WORDISH_RE.test(last)) break;
+    candidate = candidate.slice(0, -1);
+  }
+  return candidate.trim();
+}
+
+/** True when the text ends with an ASCII, fullwidth, or Arabic question mark. */
+export function endsWithQuestionMark(text: string): boolean {
+  return QUESTION_MARK_END_RE.test(text.trimEnd());
+}
+
+export function containsRecallCue(text: string, cues: readonly string[]): boolean {
+  const normalized = text.toLowerCase();
+  return cues.some((cue) => normalized.includes(cue));
+}
+
+// Exact-match acknowledgements (lowercased, trailing noise stripped).
+const ACK_CANDIDATES = new Set([
+  // English (membership identical to the previous regex alternation)
+  "ok", "okay", "kk", "thanks", "thx", "got it", "sounds good", "yep", "yes",
+  "nope", "no", "done", "cool", "works",
+  // Japanese
+  "はい", "うん", "わかった", "わかりました", "了解", "承知", "ありがとう",
+  "どうも", "おけー", "オッケー", "りょうかい",
+  // Chinese
+  "好", "好的", "嗯", "对", "行", "可以", "收到", "明白", "明白了", "知道了",
+  "谢谢", "没问题",
+  // Korean
+  "네", "응", "알겠어", "알겠습니다", "고마워", "감사합니다", "좋아",
+  // Spanish
+  "sí", "si", "gracias", "vale", "de acuerdo", "perfecto", "claro", "listo",
+  // French
+  "oui", "merci", "d'accord", "bien", "parfait", "compris", "ça marche",
+  // German
+  "ja", "danke", "gut", "verstanden", "alles klar", "passt", "einverstanden",
+  // Portuguese
+  "sim", "obrigado", "obrigada", "certo", "combinado", "beleza",
+  // Russian
+  "да", "спасибо", "ок", "хорошо", "понял", "поняла", "ясно", "угу", "принято",
+  // Arabic
+  "نعم", "شكرا", "حسنا", "تمام", "طيب", "موافق", "أوكي",
+  // Hindi
+  "हाँ", "ठीक", "अच्छा", "धन्यवाद", "समझ गया", "मंज़ूर",
+]);
+
+export function isMultilingualAck(candidate: string): boolean {
+  return ACK_CANDIDATES.has(candidate.trim().toLowerCase());
+}
+
+// Timeline / sequence / what-happened cues → graph_mode parity.
+export const GRAPH_MODE_CUES: readonly string[] = [
+  // Japanese
+  "タイムライン", "時系列", "時の流れ", "順序", "経緯", "変遷", "何があった", "どうなった",
+  // Chinese
+  "时间线", "时间轴", "时间顺序", "先后顺序", "来龙去脉", "变迁", "发生了什么", "怎么演变",
+  // Korean
+  "타임라인", "시간순", "경위", "변천", "무슨 일이 있었", "어떻게 됐", "어떻게 변했",
+  // Spanish
+  "línea de tiempo", "cronología", "cronologia", "qué pasó", "qué ocurrió", "historial",
+  // French
+  "chronologie", "frise chronologique", "qu'est-il passé", "historique",
+  // German
+  "zeitleiste", "abfolge", "ereignisfolge", "was ist passiert", "verlauf",
+  // Portuguese
+  "linha do tempo", "sequência de eventos", "o que aconteceu",
+  // Russian
+  "хронология", "последовательность событий", "что произошло", "таймлайн",
+  // Arabic
+  "الجدول الزمني", "التسلسل الزمني", "تسلسل الأحداث", "ماذا حدث",
+  // Hindi
+  "टाइमलाइन", "कालक्रम", "घटनाक्रम", "क्या हुआ",
+];
+
+// Causal-chain cues (broad graph intent).
+export const CAUSAL_CHAIN_CUES: readonly string[] = [
+  "原因", "因果", "根本原因", "怎么会",
+  "原因は", "なぜそうなった", "因果関係",
+  "원인이", "왜 이렇게", "인과",
+  "por qué pasó", "causa raíz", "cadena de causas",
+  "pourquoi c'est arrivé", "cause racine",
+  "wieso ist das passiert", "ursachenkette",
+  "por que aconteceu", "cadeia de causas",
+  "почему это произошло", "первопричина", "причинно",
+  "لماذا حدث هذا", "سلسلة الأسباب",
+  "ऐसा क्यों हुआ", "मूल कारण",
+];
+
+// Temporal-ordering markers → chronological evidence tier parity.
+export const EVENT_ORDER_CUES: readonly string[] = [
+  // Japanese
+  "最初", "初めて", "いつ", "何日", "何ヶ月", "何か月", "前に", "後で", "以降",
+  "順番", "順に", "前回", "さかのぼ", "最近",
+  // Chinese
+  "第一", "最早", "最后一次", "上次", "什么时候", "几月", "几天", "几个月",
+  "之前", "之后", "顺序", "按时间", "最近",
+  // Korean
+  "처음", "언제", "며칠", "몇 달", "몇 개월", "전에", "후에", "순서대로", "지난번",
+  // Spanish
+  "cuándo", "cuando fue", "cuántos días", "cuántos meses", "primero", "última vez",
+  "por orden", "orden cronológico",
+  // French
+  "quand ", "combien de jours", "combien de mois", "la première fois",
+  "la dernière fois", "dans l'ordre",
+  // German
+  "wann ", "wie viele tage", "wie viele monate", "zum ersten", "das letzte mal",
+  // Portuguese
+  "quando foi", "quantos dias", "quantos meses", "primeira vez", "última vez",
+  // Russian
+  "когда", "сколько дней", "сколько месяцев", "впервые", "последний раз", "по порядку",
+  // Arabic
+  "متى", "كم يوم", "كم شهر", "أول مرة", "آخر مرة", "بالترتيب",
+  // Hindi
+  "कब", "कितने दिन", "कितने महीने", "पहली बार", "आख़िरी बार",
+];
+
+// Timing/detail question cues for the response-guidance dates intent.
+export const TIMING_DETAIL_CUES: readonly string[] = [
+  "いつ", "日時", "期日", "締め切り", "締切",
+  "什么时候", "几点", "日期", "截止",
+  "언제", "날짜", "마감",
+  "qué día", "qué fecha", "fecha límite", "cuándo",
+  "quelle date", "date limite",
+  "welches datum", "frist",
+  "que dia", "que data", "prazo",
+  "какого числа", "дедлайн",
+  "تاريخ الموعد", "متى الموعد",
+  "तारीख",
+];
+
+// Contradiction-resolution cues for the response-guidance tier.
+export const CONTRADICTION_CUES: readonly string[] = [
+  "矛盾", "食い違", "前と違う", "一貫して",
+  "不一致", "之前说的", "前后矛盾",
+  "모순", "일관되",
+  "contradice", "inconsistente", "antes dijiste",
+  "contredit", "incohérent", "tu avais dit",
+  "widerspricht", "widersprüchlich",
+  "contradiz",
+  "противореч", "непоследовательн",
+  "يناقض", "تعارض",
+  "विरोधाभास",
+];
+
+// Prompt-filler words (recall verbs in other languages) that must not count
+// as content discriminators in the direct-answer gate.
+export const MULTILINGUAL_PROMPT_RECALL_WORDS: readonly string[] = [
+  "教えて", "見せて", "探して", "一覧",
+  "告诉我", "显示", "查找",
+  "보여줘", "알려줘", "찾아줘",
+  "muestra", "busca", "encuentra",
+  "montre", "cherche",
+  "zeige", "suche",
+  "покажи",
+  "أظهر", "ابحث",
+  "दिखाओ", "खोजो",
+];
+
+/** Structural heading line for non-Latin scripts: colon-terminated, short,
+ * and containing a non-ASCII letter. English prompts are unaffected. */
+export function isNonLatinHeadingLine(line: string): boolean {
+  if (line.length > 80) return false;
+  if (!COLON_TERMINATED_RE.test(line)) return false;
+  return hasNonAsciiLetter(line);
+}

package/src/recall-tokenization.ts

@@ -6,7 +6,9 @@ const DEFAULT_RECALL_STOP_WORDS = ["the", "and", "for", "with", "from", "into",
 
 export function isUnsegmentableRecallChar(char: string): boolean {
   if (char === "ー" || char === "ｰ") return true;
-  return /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]/u.test(char);
+  return /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Thai}\p{Script=Khmer}\p{Script=Lao}\p{Script=Myanmar}]/u.test(
+    char,
+  );
 }
 
 function isRecallCombiningMark(char: string): boolean {

package/src/retrieval-agents.ts

@@ -24,6 +24,8 @@ import type { QmdSearchResult } from "./types.js";
 import type { QmdClient } from "./qmd.js";
 import { isTemporalQuery, recencyWindowBoundsFromPrompt } from "./temporal-index.js";
 import { isAbortError } from "./abort-error.js";
+import { normalizeRecallTokens } from "./recall-tokenization.js";
+
 
 // ─── Types ───────────────────────────────────────────────────────────────────
 
@@ -56,10 +58,9 @@ export function shouldRunAgent(
 ): boolean {
   switch (agent) {
     case "direct":
-      // Skip only if query has no word-like tokens at all. Both capitalized and
-      // lowercase entity names are stored (normalizeEntityName lowercases them),
-      // so gating on capitalization would silently skip most real entity lookups.
-      return knownEntityCount > 0 || /\b\w{2,}/.test(query);
+      // Skip only if the query has no letter/number tokens. `\w` and `\b` are
+      // ASCII-only, so CJK entity names would never start the direct agent.
+      return knownEntityCount > 0 || /[\p{L}\p{N}]{2,}/u.test(query);
     case "temporal":
       // Only run temporal agent when the query actually asks about a time window.
       // Running it for every query injects recency bias into semantic searches.
@@ -74,12 +75,7 @@ export function shouldRunAgent(
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
 function tokenize(value: string): string[] {
-  return value
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, " ")
-    .trim()
-    .split(/\s+/)
-    .filter((t) => t.length >= 2);
+  return normalizeRecallTokens(value).filter((t) => t.length >= 2);
 }
 
 function overlapScore(queryTokens: string[], candidateTokens: string[]): number {

package/src/schemas.test.ts

@@ -0,0 +1,158 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { ConsolidationResultSchema, ExtractionResultSchema } from "./schemas.js";
+
+// Synthetic fixtures only — no real memory content (public repo).
+const validFact = {
+  category: "fact",
+  content: "The API rate limit is 1000 requests per minute.",
+  confidence: 0.8,
+  tags: ["api"],
+};
+
+const validEntity = {
+  name: "acme-corp",
+  type: "company",
+  facts: ["Uses PostgreSQL for the main database."],
+};
+
+const validQuestion = {
+  question: "Which service enforces the rate limit?",
+  context: "The limit shape suggests an upstream gateway.",
+  priority: 0.4,
+};
+
+const validRelationship = {
+  source: "person-jane-doe",
+  target: "acme-corp",
+  label: "works at",
+};
+
+function baseResult() {
+  return {
+    facts: [validFact],
+    profileUpdates: ["Prefers concise status updates."],
+    entities: [validEntity],
+    questions: [validQuestion],
+    relationships: [validRelationship],
+  };
+}
+
+test("ExtractionResultSchema salvages valid facts from a mixed-invalid array (#2455)", () => {
+  const parsed = ExtractionResultSchema.safeParse({
+    ...baseResult(),
+    facts: [
+      validFact,
+      { category: "not-a-category", content: "x", confidence: 0.5, tags: [] },
+      { category: "fact", content: "missing confidence", tags: [] },
+      // procedure facts without steps fail the superRefine — salvage must
+      // respect refinement issues, not just base-shape issues
+      { category: "procedure", content: "Deploy the service.", confidence: 0.9, tags: ["deploy"] },
+      "bare string is not a fact",
+    ],
+  });
+
+  assert.equal(parsed.success, true);
+  assert.deepEqual(parsed.data?.facts, [validFact]);
+});
+
+test("ExtractionResultSchema fails when a non-empty facts array is wholly invalid (#2455)", () => {
+  const parsed = ExtractionResultSchema.safeParse({
+    ...baseResult(),
+    facts: [
+      { category: "not-a-category", content: "x", confidence: 0.5, tags: [] },
+      42,
+    ],
+  });
+
+  assert.equal(parsed.success, false);
+  assert.ok(
+    parsed.error.issues.some((issue) => issue.message.includes("no items matching the schema")),
+  );
+});
+
+test("ExtractionResultSchema keeps explicitly empty arrays valid (#2455)", () => {
+  const parsed = ExtractionResultSchema.safeParse({
+    facts: [],
+    profileUpdates: [],
+    entities: [],
+    questions: [],
+    relationships: [],
+  });
+
+  assert.equal(parsed.success, true);
+  assert.deepEqual(parsed.data?.facts, []);
+  assert.deepEqual(parsed.data?.questions, []);
+});
+
+test("ExtractionResultSchema salvages valid entities from a mixed-invalid array (#2455)", () => {
+  const parsed = ExtractionResultSchema.safeParse({
+    ...baseResult(),
+    entities: [
+      validEntity,
+      { name: "bad-type", type: "organization", facts: ["nope"] },
+      { name: "bad-facts", type: "person", facts: [17] },
+      null,
+    ],
+  });
+
+  assert.equal(parsed.success, true);
+  assert.deepEqual(parsed.data?.entities, [validEntity]);
+});
+
+test("ExtractionResultSchema fails when a non-empty entities array is wholly invalid (#2455)", () => {
+  const parsed = ExtractionResultSchema.safeParse({
+    ...baseResult(),
+    entities: [{ name: "bad-type", type: "organization", facts: ["nope"] }],
+  });
+
+  assert.equal(parsed.success, false);
+});
+
+test("ExtractionResultSchema salvages valid questions from a mixed-invalid array (#2455)", () => {
+  const parsed = ExtractionResultSchema.safeParse({
+    ...baseResult(),
+    questions: [
+      validQuestion,
+      { question: "no context", priority: 0.3 },
+      { question: "bad priority", context: "out of range", priority: 5 },
+    ],
+  });
+
+  assert.equal(parsed.success, true);
+  assert.deepEqual(parsed.data?.questions, [validQuestion]);
+});
+
+test("ExtractionResultSchema salvages valid profileUpdates and relationships (#2455)", () => {
+  const parsed = ExtractionResultSchema.safeParse({
+    ...baseResult(),
+    profileUpdates: ["Prefers concise status updates.", 42, null],
+    relationships: [validRelationship, { source: "jane-doe", label: "missing target" }],
+  });
+
+  assert.equal(parsed.success, true);
+  assert.deepEqual(parsed.data?.profileUpdates, ["Prefers concise status updates."]);
+  assert.deepEqual(parsed.data?.relationships, [validRelationship]);
+});
+
+test("ExtractionResultSchema still accepts null/omitted relationships (#2455)", () => {
+  const nullParsed = ExtractionResultSchema.safeParse({ ...baseResult(), relationships: null });
+  assert.equal(nullParsed.success, true);
+
+  const omitted: Record<string, unknown> = { ...baseResult() };
+  delete omitted.relationships;
+  const omittedParsed = ExtractionResultSchema.safeParse(omitted);
+  assert.equal(omittedParsed.success, true);
+});
+
+test("ConsolidationResultSchema stays strict on mixed-invalid arrays (#2455)", () => {
+  const validItem = { existingId: "fact-1", action: "SKIP", reason: "still accurate" };
+  const parsed = ConsolidationResultSchema.safeParse({
+    items: [validItem, { existingId: "fact-2", action: "DESTROY", reason: "bad enum" }],
+    profileUpdates: [],
+    entityUpdates: [],
+  });
+
+  assert.equal(parsed.success, false);
+});

package/src/schemas.ts

@@ -278,27 +278,51 @@ export const ProactiveExtractionResultSchema = z.object({
     ),
 });
 
+/**
+ * Salvage array for model-produced extraction output (issue #2455).
+ *
+ * Mixed valid+invalid items parse to the valid subset so one malformed
+ * element no longer discards the whole extraction. A non-empty array with
+ * zero valid items still fails, so bounded retry stays effective and wholly
+ * malformed output is never silently accepted as empty. Empty arrays stay
+ * valid. Consolidation schemas intentionally stay strict — do not use this
+ * for them.
+ */
+function salvageArray<T extends z.ZodTypeAny>(itemSchema: T) {
+  return z
+    .array(z.unknown())
+    .transform((items, ctx) => {
+      const valid: z.infer<T>[] = [];
+      for (const raw of items) {
+        const parsed = itemSchema.safeParse(raw);
+        if (parsed.success) {
+          valid.push(parsed.data);
+        }
+      }
+      if (items.length > 0 && valid.length === 0) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: "array contains no items matching the schema",
+        });
+        return z.NEVER;
+      }
+      return valid;
+    });
+}
+
 export const ExtractionResultSchema = z.object({
-  facts: z
-    .array(ExtractedFactSchema)
-    .describe(
-      "Extracted memories from the conversation. Include facts, preferences, corrections, and decisions. Only extract genuinely new, durable information — skip transient task state.",
-    ),
-  profileUpdates: z
-    .array(z.string())
-    .describe(
-      "Updates to the user's behavioral profile. Each string is a standalone statement about the user's preferences, habits, or personality. Only include genuinely new insights.",
-    ),
-  entities: z
-    .array(EntityMentionSchema)
-    .describe(
-      "Entities mentioned in the conversation with new facts about them.",
-    ),
-  questions: z
-    .array(ExtractedQuestionSchema)
-    .describe(
-      "Zero to three source-grounded questions useful in future sessions. Return an empty array when the conversation supports none.",
-    ),
+  facts: salvageArray(ExtractedFactSchema).describe(
+    "Extracted memories from the conversation. Include facts, preferences, corrections, and decisions. Only extract genuinely new, durable information — skip transient task state.",
+  ),
+  profileUpdates: salvageArray(z.string()).describe(
+    "Updates to the user's behavioral profile. Each string is a standalone statement about the user's preferences, habits, or personality. Only include genuinely new insights.",
+  ),
+  entities: salvageArray(EntityMentionSchema).describe(
+    "Entities mentioned in the conversation with new facts about them.",
+  ),
+  questions: salvageArray(ExtractedQuestionSchema).describe(
+    "Zero to three source-grounded questions useful in future sessions. Return an empty array when the conversation supports none.",
+  ),
   identityReflection: z
     .string()
     .optional()
@@ -311,8 +335,7 @@ export const ExtractionResultSchema = z.object({
     .optional()
     .nullable()
     .describe("A six-to-eight word title for this conversation segment."),
-  relationships: z
-    .array(ExtractedRelationshipSchema)
+  relationships: salvageArray(ExtractedRelationshipSchema)
     .optional()
     .nullable()
     .describe(

package/dist/chunk-6GGTATZF.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/direct-answer.ts"],"sourcesContent":["/**\n * Direct-answer retrieval tier eligibility (issue #518 slice 2).\n *\n * This module is a pure decision layer.  It takes a query, a set of\n * caller-resolved candidates (each already decorated with trust-zone,\n * taxonomy-bucket, and importance information), and the direct-answer\n * config, then returns an eligibility verdict.\n *\n * Keeping the module pure means:\n *\n * - Tests do not need a trust-zones store, taxonomy resolver, or importance\n *   scorer on disk.\n * - Slice 3 (retrieval.ts wiring) is responsible for resolving those signals\n *   before calling in; the wiring layer decides where candidates come from\n *   (entity index, token prefilter, etc.).  This module only decides\n *   whether the surfaced candidates add up to a confident direct answer.\n *\n * Not wired into retrieval yet — see slice 3.\n */\n\nimport { normalizeRecallTokenSet, normalizeRecallTokens } from \"./recall-tokenization.js\";\nimport type { TrustZoneName } from \"./trust-zones.js\";\nimport type { MemoryFile, MemoryStatus } from \"./types.js\";\n\n/**\n * Caller-supplied candidate.\n *\n * `trustZone`, `taxonomyBucket`, and `importanceScore` are resolved outside\n * this module because each comes from a different subsystem.  Passing them\n * as inputs keeps the function deterministic and easy to unit-test.\n *\n * `matchScore` is optional; if omitted, candidates are ranked by\n * token-overlap ratio.  Callers that already computed a better ranking\n * score (e.g. BM25, vector similarity) can supply it to drive the\n * ambiguity check.\n */\nexport interface DirectAnswerCandidate {\n  memory: MemoryFile;\n  trustZone: TrustZoneName | null;\n  taxonomyBucket: string | null;\n  importanceScore: number;\n  matchScore?: number;\n}\n\nexport interface DirectAnswerConfig {\n  enabled: boolean;\n  tokenOverlapFloor: number;\n  importanceFloor: number;\n  ambiguityMargin: number;\n  eligibleTaxonomyBuckets: string[];\n}\n\nexport interface DirectAnswerInput {\n  query: string;\n  candidates: DirectAnswerCandidate[];\n  config: DirectAnswerConfig;\n  /**\n   * Optional entity-ref hints resolved from the query upstream.  When\n   * supplied, a candidate with a set `entityRef` must match one of these\n   * (case-insensitive) to remain eligible.  Candidates without an\n   * `entityRef` are allowed through regardless.\n   */\n  queryEntityRefs?: string[];\n}\n\nexport type DirectAnswerReason =\n  | \"disabled\"\n  | \"empty-query\"\n  | \"no-candidates\"\n  | \"no-eligible-candidates\"\n  | \"below-token-overlap-floor\"\n  | \"ambiguous\"\n  | \"eligible\";\n\nexport interface DirectAnswerResult {\n  eligible: boolean;\n  reason: DirectAnswerReason;\n  /** Winning candidate when eligible. */\n  winner?: DirectAnswerCandidate;\n  /** Computed token-overlap ratio (0..1) of the winner. */\n  tokenOverlap?: number;\n  /**\n   * Human-readable summary suitable for\n   * `RecallTierExplain.tierReason`.\n   */\n  narrative: string;\n  /**\n   * Filter labels that eliminated at least one candidate along the way.\n   * Populated regardless of eligibility so the caller can surface the\n   * narrowing steps in `RecallTierExplain.filteredBy`.\n   */\n  filteredBy: string[];\n}\n\n/** Filter labels — exported so callers and tests can match them structurally. */\nexport const FILTER_LABELS = {\n  nonActiveStatus: \"non-active-status\",\n  notTrustedZone: \"not-trusted-zone\",\n  ineligibleTaxonomyBucket: \"ineligible-taxonomy-bucket\",\n  belowImportanceFloor: \"below-importance-floor\",\n  entityRefMismatch: \"entity-ref-mismatch\",\n  belowTokenOverlapFloor: \"below-token-overlap-floor\",\n} as const;\n\nconst PROMPT_RECALL_WORDS = new Set([\n  \"what\",\n  \"who\",\n  \"where\",\n  \"when\",\n  \"why\",\n  \"how\",\n  \"is\",\n  \"are\",\n  \"was\",\n  \"were\",\n  \"do\",\n  \"does\",\n  \"did\",\n  \"find\",\n  \"get\",\n  \"show\",\n  \"search\",\n  \"lookup\",\n  \"recall\",\n  \"remember\",\n  \"list\",\n  \"status\",\n  \"include\",\n  \"tell\",\n  \"me\",\n  \"give\",\n  \"about\",\n  \"please\",\n  \"the\",\n  \"and\",\n  \"for\",\n  \"with\",\n  \"from\",\n  \"into\",\n  \"that\",\n  \"this\",\n  \"найди\",\n  \"найти\",\n  \"поиск\",\n  \"покажи\",\n  \"статус\",\n  \"включи\",\n]);\n\ninterface ScoredCandidate {\n  candidate: DirectAnswerCandidate;\n  tokenOverlap: number;\n  requiredTokenMismatch: boolean;\n}\n\nfunction hasUnsegmentableRecallChar(token: string): boolean {\n  if (token.includes(\"ー\") || token.includes(\"ｰ\")) return true;\n  return /[\\p{Script=Han}\\p{Script=Hiragana}\\p{Script=Katakana}]/u.test(token);\n}\n\nfunction requiredCjkPhraseTokens(query: string): string[] {\n  const phrases = new Set<string>();\n  let segment = \"\";\n\n  const addPhrase = (phrase: string) => {\n    if ([...phrase].length >= 4) {\n      phrases.add(phrase);\n    }\n  };\n\n  const flushSegment = () => {\n    let buffered = \"\";\n    for (const run of segment.split(/\\s+/)) {\n      if (!run) continue;\n      if ([...run].length >= 4) {\n        addPhrase(buffered);\n        buffered = \"\";\n        addPhrase(run);\n        continue;\n      }\n      buffered += run;\n    }\n    addPhrase(buffered);\n    segment = \"\";\n  };\n\n  for (const ch of query.toLowerCase().normalize(\"NFC\")) {\n    if (hasUnsegmentableRecallChar(ch)) {\n      segment += ch;\n      continue;\n    }\n    if (/\\p{M}/u.test(ch) && segment.length > 0 && !/\\s$/u.test(segment)) {\n      segment += ch;\n      continue;\n    }\n    if (/\\s/u.test(ch)) {\n      segment += \" \";\n      continue;\n    }\n    flushSegment();\n  }\n  flushSegment();\n\n  return [...phrases];\n}\n\nfunction requiredMixedScriptTokens(query: string): string[] {\n  const required = new Set<string>();\n  const parts: string[] = [];\n  let segment = \"\";\n\n  const flushSegment = () => {\n    if (segment) {\n      parts.push(segment);\n    }\n    segment = \"\";\n  };\n\n  const segmentableRecallTokens = (value: string) => {\n    const tokens = new Set<string>();\n    let segment = \"\";\n    const flushSegmentableSegment = () => {\n      for (const token of normalizeRecallTokenSet(segment, [], { minTokenLength: 1 })) {\n        tokens.add(token);\n      }\n      segment = \"\";\n    };\n\n    for (const ch of value) {\n      if (/[\\p{L}\\p{N}]/u.test(ch) && !hasUnsegmentableRecallChar(ch)) {\n        segment += ch;\n        continue;\n      }\n      if (/\\p{M}/u.test(ch) && segment.length > 0) {\n        segment += ch;\n        continue;\n      }\n      flushSegmentableSegment();\n    }\n    flushSegmentableSegment();\n    return tokens;\n  };\n\n  const hasRequiredSegmentableToken = (value: string) => {\n    return segmentableRecallTokens(value).size > 0;\n  };\n\n  const hasBoundarySegmentableToken = (value: string) => {\n    for (const token of segmentableRecallTokens(value)) {\n      if (PROMPT_RECALL_WORDS.has(token)) {\n        continue;\n      }\n      const hasNonAsciiCodepoint = [...token].some((ch) => (ch.codePointAt(0) ?? 0) > 0x7f);\n      if (token.length >= 3 || /\\p{N}/u.test(token) || hasNonAsciiCodepoint) {\n        return true;\n      }\n    }\n    return false;\n  };\n\n  const addRequiredTokens = (value: string) => {\n    for (const token of normalizeRecallTokenSet(value, [], { minTokenLength: 1 })) {\n      required.add(token);\n    }\n  };\n\n  for (const ch of query.toLowerCase().normalize(\"NFC\")) {\n    if (/[\\p{L}\\p{N}\\p{M}]/u.test(ch) || hasUnsegmentableRecallChar(ch)) {\n      segment += ch;\n      continue;\n    }\n    flushSegment();\n  }\n  flushSegment();\n\n  for (const part of parts) {\n    if (hasUnsegmentableRecallChar(part) && hasRequiredSegmentableToken(part)) {\n      addRequiredTokens(part);\n    }\n  }\n\n  for (let i = 0; i < parts.length - 1; i += 1) {\n    const current = parts[i];\n    const next = parts[i + 1];\n    const currentHasUnsegmentable = hasUnsegmentableRecallChar(current);\n    const nextHasUnsegmentable = hasUnsegmentableRecallChar(next);\n    if (currentHasUnsegmentable === nextHasUnsegmentable) {\n      continue;\n    }\n    const segmentablePart = currentHasUnsegmentable ? next : current;\n    if (!hasBoundarySegmentableToken(segmentablePart)) {\n      continue;\n    }\n    addRequiredTokens(current);\n    addRequiredTokens(next);\n  }\n\n  for (let i = 1; i < parts.length - 1; i += 1) {\n    const prev = parts[i - 1];\n    const current = parts[i];\n    const next = parts[i + 1];\n    if (!hasUnsegmentableRecallChar(prev) || hasUnsegmentableRecallChar(current) || !hasUnsegmentableRecallChar(next)) {\n      continue;\n    }\n    if (!hasRequiredSegmentableToken(current)) {\n      continue;\n    }\n    addRequiredTokens(prev);\n    addRequiredTokens(current);\n    addRequiredTokens(next);\n  }\n\n  return [...required];\n}\n\nfunction requiredSegmentableUnicodeTokens(queryTokens: Set<string>): string[] {\n  const segmentableTokens = [...queryTokens].filter((token) => !hasUnsegmentableRecallChar(token));\n  const hasSegmentableUnicodeToken = segmentableTokens.some((token) =>\n    [...token].some((ch) => (ch.codePointAt(0) ?? 0) > 0x7f)\n  );\n  if (!hasSegmentableUnicodeToken) {\n    return [];\n  }\n  return segmentableTokens.filter((token) => {\n    if (PROMPT_RECALL_WORDS.has(token)) {\n      return false;\n    }\n    const hasNonAsciiCodepoint = [...token].some((ch) => (ch.codePointAt(0) ?? 0) > 0x7f);\n    if (hasNonAsciiCodepoint) {\n      return true;\n    }\n    if (!/^[a-z0-9]+$/u.test(token)) {\n      return false;\n    }\n    return token.length >= 3 || /\\p{N}/u.test(token);\n  });\n}\n\nfunction countTokenOverlap(queryTokens: Set<string>, valueTokens: Set<string>): number {\n  let matches = 0;\n  for (const token of queryTokens) {\n    if (valueTokens.has(token)) matches += 1;\n  }\n  return matches;\n}\n\n/**\n * Determine whether a query can be served by the direct-answer tier.\n *\n * Decision ladder, in order:\n *\n *   1. config.enabled === false → \"disabled\"\n *   2. empty query tokens → \"empty-query\"\n *   3. empty candidates → \"no-candidates\"\n *   4. hard filters drop all candidates → \"no-eligible-candidates\"\n *   5. token-overlap floor drops all → \"below-token-overlap-floor\"\n *   6. top two candidates within ambiguityMargin → \"ambiguous\"\n *   7. otherwise → \"eligible\"\n */\nexport function isDirectAnswerEligible(input: DirectAnswerInput): DirectAnswerResult {\n  const { query, candidates, config, queryEntityRefs } = input;\n\n  if (!config.enabled) {\n    return {\n      eligible: false,\n      reason: \"disabled\",\n      narrative: \"direct-answer tier is disabled\",\n      filteredBy: [],\n    };\n  }\n\n  const queryTokens = new Set(normalizeRecallTokens(query));\n  if (queryTokens.size === 0) {\n    return {\n      eligible: false,\n      reason: \"empty-query\",\n      narrative: \"query has no searchable tokens after normalization\",\n      filteredBy: [],\n    };\n  }\n\n  if (candidates.length === 0) {\n    return {\n      eligible: false,\n      reason: \"no-candidates\",\n      narrative: \"no candidates supplied\",\n      filteredBy: [],\n    };\n  }\n\n  const filteredBy: string[] = [];\n  let working: DirectAnswerCandidate[] = candidates;\n\n  working = applyFilter(working, filteredBy, FILTER_LABELS.nonActiveStatus, (c) => {\n    const status: MemoryStatus = c.memory.frontmatter.status ?? \"active\";\n    return status === \"active\";\n  });\n\n  working = applyFilter(working, filteredBy, FILTER_LABELS.notTrustedZone, (c) => c.trustZone === \"trusted\");\n\n  working = applyFilter(\n    working,\n    filteredBy,\n    FILTER_LABELS.ineligibleTaxonomyBucket,\n    (c) => c.taxonomyBucket !== null && config.eligibleTaxonomyBuckets.includes(c.taxonomyBucket)\n  );\n\n  working = applyFilter(working, filteredBy, FILTER_LABELS.belowImportanceFloor, (c) => {\n    if (c.memory.frontmatter.verificationState === \"user_confirmed\") return true;\n    return c.importanceScore >= config.importanceFloor;\n  });\n\n  if (queryEntityRefs && queryEntityRefs.length > 0) {\n    const normRefs = new Set(queryEntityRefs.map((r) => r.toLowerCase()));\n    working = applyFilter(working, filteredBy, FILTER_LABELS.entityRefMismatch, (c) => {\n      const ref = c.memory.frontmatter.entityRef;\n      if (!ref) return true;\n      return normRefs.has(ref.toLowerCase());\n    });\n  }\n\n  if (working.length === 0) {\n    return {\n      eligible: false,\n      reason: \"no-eligible-candidates\",\n      narrative: \"no candidates survived eligibility filters\",\n      filteredBy,\n    };\n  }\n\n  const scored: ScoredCandidate[] = working.map((candidate) => {\n    const searchable = `${candidate.memory.frontmatter.tags?.join(\" \") ?? \"\"} ${candidate.memory.content}`.trim();\n    const searchableTokens = normalizeRecallTokenSet(searchable);\n    const requiredSearchableTokens = normalizeRecallTokenSet(searchable, [], { minTokenLength: 1 });\n    const requiredPhrases = requiredCjkPhraseTokens(query);\n    const requiredMixedTokens = requiredMixedScriptTokens(query);\n    const requiredUnicodeTokens = requiredSegmentableUnicodeTokens(queryTokens);\n    const hasRequiredPhrase =\n      requiredPhrases.length === 0 || requiredPhrases.every((token) => searchableTokens.has(token));\n    const hasRequiredMixedTokens =\n      requiredMixedTokens.length === 0 || requiredMixedTokens.every((token) => requiredSearchableTokens.has(token));\n    const hasRequiredUnicodeTokens =\n      requiredUnicodeTokens.length === 0 || requiredUnicodeTokens.every((token) => searchableTokens.has(token));\n    const requiredTokenMismatch = !hasRequiredPhrase || !hasRequiredMixedTokens || !hasRequiredUnicodeTokens;\n    const matches = requiredTokenMismatch ? 0 : countTokenOverlap(queryTokens, searchableTokens);\n    return { candidate, tokenOverlap: matches / queryTokens.size, requiredTokenMismatch };\n  });\n\n  const overlapSurvivors = scored.filter((s) => !s.requiredTokenMismatch && s.tokenOverlap >= config.tokenOverlapFloor);\n  if (overlapSurvivors.length < scored.length) {\n    filteredBy.push(FILTER_LABELS.belowTokenOverlapFloor);\n  }\n\n  if (overlapSurvivors.length === 0) {\n    return {\n      eligible: false,\n      reason: \"below-token-overlap-floor\",\n      narrative: `no candidate met token-overlap floor ${config.tokenOverlapFloor}`,\n      filteredBy,\n    };\n  }\n\n  overlapSurvivors.sort(compareScored);\n\n  if (overlapSurvivors.length >= 2) {\n    const topScore = scoreFor(overlapSurvivors[0]);\n    const secondScore = scoreFor(overlapSurvivors[1]);\n    if (topScore - secondScore < config.ambiguityMargin) {\n      return {\n        eligible: false,\n        reason: \"ambiguous\",\n        narrative: `top two candidates within ambiguityMargin ${config.ambiguityMargin}`,\n        filteredBy,\n      };\n    }\n  }\n\n  const winner = overlapSurvivors[0];\n  const bucket = winner.candidate.taxonomyBucket ?? \"unknown\";\n  return {\n    eligible: true,\n    reason: \"eligible\",\n    winner: winner.candidate,\n    tokenOverlap: winner.tokenOverlap,\n    narrative: `trusted ${bucket}, unambiguous, token-overlap ${winner.tokenOverlap.toFixed(2)}`,\n    filteredBy,\n  };\n}\n\nfunction applyFilter(\n  working: DirectAnswerCandidate[],\n  filteredBy: string[],\n  label: string,\n  keep: (c: DirectAnswerCandidate) => boolean\n): DirectAnswerCandidate[] {\n  const before = working.length;\n  const next = working.filter(keep);\n  if (next.length < before) filteredBy.push(label);\n  return next;\n}\n\nfunction scoreFor(s: ScoredCandidate): number {\n  return s.candidate.matchScore ?? s.tokenOverlap;\n}\n\nfunction compareScored(a: ScoredCandidate, b: ScoredCandidate): number {\n  const diff = scoreFor(b) - scoreFor(a);\n  if (diff !== 0) return diff;\n  // Stable secondary key on path so the comparator returns 0 only for equal\n  // entries (CLAUDE.md rule 19).\n  return a.candidate.memory.path.localeCompare(b.candidate.memory.path);\n}\n"],"mappings":"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","names":["segment"]}