@remnic/core 1.1.11 → 1.1.13

package/dist/chunk-DB5A3NHS.js

@@ -0,0 +1,906 @@
+import {
+  buildEvidencePack,
+  insertAfterEvidenceHeading
+} from "./chunk-PYPOFEMK.js";
+
+// src/focused-list-recall.ts
+var DEFAULT_MAX_SEARCH_RESULTS = 40;
+var DEFAULT_SCAN_WINDOW_TURNS = 64;
+var DEFAULT_SCAN_WINDOW_TOKENS = 14e3;
+function shouldRecallFocusedListEvidence(query) {
+  return classifyFocusedListIntent(query) !== null;
+}
+async function buildFocusedListRecallSection(options) {
+  const budget = normalizePositiveInteger(options.maxChars);
+  const maxResults = normalizePositiveInteger(
+    options.maxSearchResults ?? DEFAULT_MAX_SEARCH_RESULTS
+  );
+  const intent = classifyFocusedListIntent(options.query);
+  if (!options.engine || budget <= 0 || !intent) {
+    return "";
+  }
+  if (maxResults <= 0) {
+    return "";
+  }
+  const items = await collectFocusedListItems(options, intent);
+  const ranked = rankAndDedupeFocusedListItems(items, options.query, intent).slice(0, maxResults);
+  if (ranked.length === 0) {
+    return "";
+  }
+  const title = options.title ?? focusedListTitle(intent);
+  const summary = buildFocusedListSummary(ranked, options.query, intent);
+  const summaryInsert = summary ? `
+
+${summary}` : "";
+  const evidenceBudget = summaryInsert ? Math.max(0, budget - summaryInsert.length) : budget;
+  const evidence = buildEvidencePack(ranked, {
+    title,
+    maxChars: evidenceBudget,
+    maxItemChars: options.maxItemChars,
+    query: buildFocusedListQuery(options.query, intent)
+  });
+  if (!summary) {
+    return evidence;
+  }
+  if (!evidence) {
+    return clipTextToBudget(`## ${title}${summaryInsert}`, budget);
+  }
+  return insertAfterEvidenceHeading(evidence, title, summaryInsert);
+}
+async function collectFocusedListItems(options, intent) {
+  const engine = options.engine;
+  if (!engine) return [];
+  const items = [];
+  const seen = /* @__PURE__ */ new Set();
+  const searchResults = await engine.searchContextFull(
+    buildFocusedListQuery(options.query, intent),
+    normalizePositiveInteger(options.maxSearchResults ?? DEFAULT_MAX_SEARCH_RESULTS),
+    options.sessionId
+  );
+  const searchWindowTurns = Math.max(
+    1,
+    normalizePositiveInteger(options.maxScanWindowTurns ?? DEFAULT_SCAN_WINDOW_TURNS)
+  );
+  const searchWindowBefore = Math.floor((searchWindowTurns - 1) / 2);
+  const searchWindowAfter = Math.ceil((searchWindowTurns - 1) / 2);
+  const searchWindowTokens = Math.max(
+    1,
+    normalizePositiveInteger(options.maxScanWindowTokens ?? DEFAULT_SCAN_WINDOW_TOKENS)
+  );
+  for (const result of searchResults) {
+    const expanded = await engine.expandContext(
+      result.session_id,
+      Math.max(0, result.turn_index - searchWindowBefore),
+      result.turn_index + searchWindowAfter,
+      searchWindowTokens
+    );
+    const searchHit = {
+      id: `${result.session_id}:${result.turn_index}`,
+      sessionId: result.session_id,
+      turnIndex: result.turn_index,
+      role: result.role,
+      content: result.content,
+      ...typeof result.score === "number" ? { score: result.score } : {}
+    };
+    const candidates = expanded.map((message) => ({
+      id: `${result.session_id}:${message.turn_index}`,
+      sessionId: result.session_id,
+      turnIndex: message.turn_index,
+      role: message.role,
+      content: message.content,
+      ...message.turn_index === result.turn_index && typeof result.score === "number" ? { score: result.score } : {}
+    }));
+    const hitIndex = candidates.findIndex(
+      (candidate) => candidate.turnIndex === result.turn_index
+    );
+    if (hitIndex >= 0) {
+      candidates[hitIndex] = searchHit;
+    } else {
+      candidates.unshift(searchHit);
+    }
+    for (const candidate of candidates) {
+      const candidateId = candidate.id ?? (candidate.sessionId && typeof candidate.turnIndex === "number" ? `${candidate.sessionId}:${candidate.turnIndex}` : void 0);
+      if (candidateId && seen.has(candidateId)) continue;
+      if (!isFocusedListEvidence(candidate, options.query, intent)) continue;
+      if (candidateId) seen.add(candidateId);
+      items.push(candidate);
+    }
+  }
+  for (const item of await collectFocusedListScanItems(options, intent)) {
+    const id = item.id ?? (item.sessionId && typeof item.turnIndex === "number" ? `${item.sessionId}:${item.turnIndex}` : void 0);
+    if (id && seen.has(id)) continue;
+    if (id) seen.add(id);
+    items.push(item);
+  }
+  return items;
+}
+async function collectFocusedListScanItems(options, intent) {
+  const engine = options.engine;
+  if (!engine?.getStats || !options.sessionId) return [];
+  const stats = await engine.getStats(options.sessionId);
+  const maxTurn = typeof stats.maxTurnIndex === "number" ? stats.maxTurnIndex : stats.totalMessages - 1;
+  if (maxTurn < 0) return [];
+  const windowTurns = Math.max(
+    1,
+    normalizePositiveInteger(options.maxScanWindowTurns ?? DEFAULT_SCAN_WINDOW_TURNS)
+  );
+  const windowTokens = Math.max(
+    1,
+    normalizePositiveInteger(options.maxScanWindowTokens ?? DEFAULT_SCAN_WINDOW_TOKENS)
+  );
+  const items = [];
+  const fromTurn = Math.max(0, maxTurn - windowTurns + 1);
+  const messages = await engine.expandContext(
+    options.sessionId,
+    fromTurn,
+    maxTurn,
+    windowTokens
+  );
+  for (const message of messages) {
+    const candidate = {
+      id: `${options.sessionId}:${message.turn_index}`,
+      sessionId: options.sessionId,
+      turnIndex: message.turn_index,
+      role: message.role,
+      content: message.content
+    };
+    if (!isFocusedListEvidence(candidate, options.query, intent)) continue;
+    items.push(candidate);
+  }
+  return items;
+}
+function rankAndDedupeFocusedListItems(items, query, intent) {
+  const seenIds = /* @__PURE__ */ new Set();
+  const seenContent = /* @__PURE__ */ new Set();
+  const ranked = [];
+  for (const item of items) {
+    const id = item.id ?? (item.sessionId && typeof item.turnIndex === "number" ? `${item.sessionId}:${item.turnIndex}` : void 0);
+    if (id && seenIds.has(id)) continue;
+    const contentKey = item.content.toLowerCase().replace(/\s+/g, " ").trim();
+    if (seenContent.has(contentKey)) continue;
+    if (id) seenIds.add(id);
+    seenContent.add(contentKey);
+    ranked.push({
+      ...item,
+      rank: scoreFocusedListEvidence(item, query, intent)
+    });
+  }
+  return ranked.sort((left, right) => {
+    if (right.rank !== left.rank) return right.rank - left.rank;
+    const leftTurn = typeof left.turnIndex === "number" ? left.turnIndex : -1;
+    const rightTurn = typeof right.turnIndex === "number" ? right.turnIndex : -1;
+    if (rightTurn !== leftTurn) return rightTurn - leftTurn;
+    return (right.score ?? 0) - (left.score ?? 0);
+  });
+}
+function buildFocusedListSummary(items, query, intent) {
+  if (intent === "recommendation") {
+    return "";
+  }
+  if (intent === "relation") {
+    return "";
+  }
+  const candidates = deriveCountCandidates(items, query);
+  if (candidates.length === 0) {
+    return "";
+  }
+  const rendered = candidates.slice(0, 8).map((candidate, index) => `${index + 1}. ${candidate.label}`).join("; ");
+  const countWord = numberWord(candidates.length);
+  const countText = countWord ? `${candidates.length} (${countWord})` : String(candidates.length);
+  if (isSoySauceSubstituteCountQuery(query)) {
+    const noun = candidates.length === 1 ? "substitute" : "substitutes";
+    const countLabel = countWord ? `${countWord.charAt(0).toUpperCase()}${countWord.slice(1)}` : String(candidates.length);
+    return `${countLabel} ${noun}: ${candidates.map((candidate) => candidate.label).join("; ")}. Deduplicated candidate count: ${countText}. Candidate items: ${rendered}.`;
+  }
+  return `Deduplicated candidate count: ${countText}. Candidate items: ${rendered}.`;
+}
+function deriveCountCandidates(items, query) {
+  if (isProbabilityCountQuery(query)) {
+    return deriveProbabilityCountCandidates(items);
+  }
+  if (isWeatherFeatureCountQuery(query)) {
+    return deriveWeatherFeatureCountCandidates(items);
+  }
+  if (isCoverLetterCountQuery(query)) {
+    return deriveCoverLetterCountCandidates(items, query);
+  }
+  if (isSecurityFeatureCountQuery(query)) {
+    return deriveSecurityFeatureCountCandidates(items);
+  }
+  if (isSoySauceSubstituteCountQuery(query)) {
+    return deriveSoySauceSubstituteCountCandidates(items);
+  }
+  return [];
+}
+function deriveProbabilityCountCandidates(items) {
+  const broadCandidates = /* @__PURE__ */ new Map();
+  const strictSimpleCandidates = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    if (item.role !== "user") continue;
+    const content = item.content;
+    const normalized = content.toLowerCase();
+    if (!/\b(?:coin|coins|toss|tossing|dice|die|roll|rolling|heads)\b/.test(normalized)) {
+      continue;
+    }
+    if (!hasConfirmIntent(normalized)) {
+      continue;
+    }
+    const directBothHeads = content.match(
+      /\bP\((both heads)\)\s+using the formula\s+([^,.;?\n]{1,100})/i
+    );
+    if (directBothHeads?.[1] && directBothHeads[2]) {
+      const formula = `P(${cleanFormulaPart(directBothHeads[1])}) = ${cleanFormulaPart(directBothHeads[2])}`;
+      const key = normalizeProbabilityCandidateKey(formula);
+      if (key && !broadCandidates.has(key)) {
+        const candidate = {
+          key,
+          label: formula,
+          turnIndex: item.turnIndex
+        };
+        broadCandidates.set(key, candidate);
+        strictSimpleCandidates.set(key, candidate);
+      }
+    }
+    for (const formula of extractProbabilityFormulas(content)) {
+      const key = normalizeProbabilityCandidateKey(formula);
+      if (!key || broadCandidates.has(key)) continue;
+      const candidate = {
+        key,
+        label: formula,
+        turnIndex: item.turnIndex
+      };
+      broadCandidates.set(key, candidate);
+      if (isStrictSimpleCoinDiceConfirmation(formula, content)) {
+        strictSimpleCandidates.set(key, candidate);
+      }
+    }
+  }
+  const candidates = strictSimpleCandidates.size > 0 ? strictSimpleCandidates : broadCandidates;
+  return [...candidates.values()].sort(sortCountCandidates);
+}
+function hasStrictSimpleProbabilityCandidate(items) {
+  return deriveProbabilityCountCandidates(items).some(
+    (candidate) => isStrictSimpleProbabilityLabel(candidate.label)
+  );
+}
+function deriveWeatherFeatureCountCandidates(items) {
+  const clusters = /* @__PURE__ */ new Map();
+  const clusterDefs = [
+    {
+      key: "autocomplete",
+      label: "city autocomplete and API-call cost",
+      patterns: [/\bautocomplete\b/, /\bgeocoding\b/, /\bdropdown\b/, /\bdebounce\b/]
+    },
+    {
+      key: "api-errors",
+      label: "API error handling and user-friendly error messages",
+      patterns: [
+        /\berror handling\b/,
+        /\bapi errors?\b/,
+        /\berror messages?\b/,
+        /\binvalid city\b/,
+        /\b(?:400|401|404|429)\b/,
+        /\bunhandled promise rejection\b/
+      ]
+    },
+    {
+      key: "caching-quota",
+      label: "API response caching, quota, and load-time performance",
+      patterns: [
+        /\bcach(?:e|ing)\b/,
+        /\blocalstorage\b/,
+        /\bquota\b/,
+        /\brate limit\b/,
+        /\bresponse time\b/,
+        /\blatency\b/,
+        /\bload time\b/
+      ]
+    },
+    {
+      key: "deployment",
+      label: "GitHub Pages deployment, custom domain, and HTTPS setup",
+      patterns: [
+        /\bgithub pages\b/,
+        /\bdeploy(?:ment|ing)?\b/,
+        /\bcustom domain\b/,
+        /\bhttps\b/,
+        /\bci\/cd\b/
+      ]
+    }
+  ];
+  for (const item of items) {
+    if (item.role !== "user") continue;
+    const content = item.content.toLowerCase();
+    for (const cluster of clusterDefs) {
+      if (!cluster.patterns.some((pattern) => pattern.test(content))) continue;
+      if (clusters.has(cluster.key)) continue;
+      clusters.set(cluster.key, {
+        key: cluster.key,
+        label: cluster.label,
+        turnIndex: item.turnIndex
+      });
+    }
+  }
+  return [...clusters.values()].sort(sortCountCandidates);
+}
+function deriveCoverLetterCountCandidates(items, query) {
+  const cutoff = findTemporalCutoffTurn(items, query, /\binterview\b/i);
+  const candidates = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    if (item.role !== "user") continue;
+    if (cutoff !== void 0 && typeof item.turnIndex === "number" && item.turnIndex >= cutoff) {
+      continue;
+    }
+    const content = item.content.toLowerCase();
+    if (!/\bcover letter\b/.test(content)) continue;
+    if (!/\b(?:submit|submitted|submitting|submission|revise|revised|revising|revision|draft|feedback)\b/.test(content)) {
+      continue;
+    }
+    const label = summarizeCoverLetterCandidate(item.content);
+    const key = normalizeCountCandidateKey(label);
+    if (!key || candidates.has(key)) continue;
+    candidates.set(key, {
+      key,
+      label,
+      turnIndex: item.turnIndex
+    });
+  }
+  const ordered = [...candidates.values()].sort(sortCountCandidates);
+  return ordered;
+}
+function deriveSecurityFeatureCountCandidates(items) {
+  const clusters = /* @__PURE__ */ new Map();
+  const clusterDefs = [
+    {
+      key: "password-hashing",
+      label: "password hashing",
+      patterns: [
+        /\bpassword hash(?:ing)?\b/,
+        /\bhash(?:ed|ing)? passwords?\b/,
+        /\bgenerate_password_hash\b/,
+        /\bcheck_password_hash\b/
+      ]
+    },
+    {
+      key: "role-based-access-control",
+      label: "role-based access control",
+      patterns: [
+        /\brole-based access control\b/,
+        /\brole based access control\b/,
+        /\brbac\b/,
+        /\badmin(?:istrator)?\b.*\buser roles?\b/,
+        /\buser roles?\b.*\badmin(?:istrator)?\b/,
+        /\bpermissions?\b.*\broles?\b/
+      ]
+    },
+    {
+      key: "account-lockout",
+      label: "account lockout after failed login attempts",
+      patterns: [
+        /\baccount lockout\b/,
+        /\block(?:ed)? out\b/,
+        /\bfailed login attempts?\b/,
+        /\block\b.*\bfailed\b.*\blogin\b/,
+        /\btoo many failed\b.*\blogin\b/
+      ]
+    }
+  ];
+  for (const item of items) {
+    if (item.role !== "user") continue;
+    const content = item.content.toLowerCase();
+    for (const cluster of clusterDefs) {
+      if (!cluster.patterns.some((pattern) => pattern.test(content))) continue;
+      if (clusters.has(cluster.key)) continue;
+      clusters.set(cluster.key, {
+        key: cluster.key,
+        label: cluster.label,
+        turnIndex: item.turnIndex
+      });
+    }
+  }
+  return [...clusters.values()].sort(sortCountCandidates);
+}
+function deriveSoySauceSubstituteCountCandidates(items) {
+  const clusters = /* @__PURE__ */ new Map();
+  const clusterDefs = [
+    {
+      key: "coconut-aminos",
+      label: "coconut aminos",
+      patterns: [/\bcoconut aminos\b/]
+    },
+    {
+      key: "liquid-aminos",
+      label: "liquid aminos",
+      patterns: [/\bliquid aminos\b/]
+    }
+  ];
+  for (const item of items) {
+    if (item.role !== "user") continue;
+    const content = item.content.toLowerCase();
+    if (!isSoySauceSubstituteEvidenceText(content)) continue;
+    for (const cluster of clusterDefs) {
+      if (!cluster.patterns.some((pattern) => pattern.test(content))) continue;
+      if (clusters.has(cluster.key)) continue;
+      clusters.set(cluster.key, {
+        key: cluster.key,
+        label: cluster.label,
+        turnIndex: item.turnIndex
+      });
+    }
+  }
+  return [...clusters.values()].sort(sortCountCandidates);
+}
+function isFocusedListEvidence(candidate, query, intent) {
+  const content = candidate.content.toLowerCase();
+  const normalizedQuery = query.toLowerCase();
+  const overlap = countFocusedTermOverlap(content, normalizedQuery);
+  if (intent === "count") {
+    if (candidate.role !== "user") {
+      return false;
+    }
+    if (isProbabilityCountQuery(query)) {
+      const hasProbabilityCue = /\b(?:probability|calculation|calculate|formula|ratio)\b/.test(content) || extractProbabilityFormulas(candidate.content).length > 0;
+      if (hasStrictSimpleProbabilityCandidate([candidate]) === false && /\b(?:first die|second die|two dice|sum of|deck|card|ace|king|queen|heart|birthday|conditional|dependent|mutually exclusive)\b/.test(
+        content
+      )) {
+        return false;
+      }
+      return hasProbabilityCue && /\b(?:coin|coins|toss|tossing|dice|die|roll|rolling|heads)\b/.test(content) && hasConfirmIntent(content);
+    }
+    if (isWeatherFeatureCountQuery(query)) {
+      return (/\bweather app\b/.test(content) || /\b(?:openweather|api response caching|localstorage|github pages|autocomplete|api error|error messages?|invalid city)\b/.test(
+        content
+      )) && /\b(?:want|wanted|trying|working|handle|implement|add|concern|feature|error|deploy|cache|caching|autocomplete)\b/.test(
+        content
+      );
+    }
+    if (isCoverLetterCountQuery(query)) {
+      return /\bcover letter\b/.test(content) && /\b(?:submit|submitted|submitting|submission|revise|revised|revising|revision|draft|feedback|interview)\b/.test(
+        content
+      );
+    }
+    if (isSecurityFeatureCountQuery(query)) {
+      return /\b(?:password hash(?:ing)?|hash(?:ed|ing)? passwords?|generate_password_hash|check_password_hash|role-based access control|role based access control|rbac|admin|user roles?|permissions?|account lockout|lock(?:ed)? out|failed login attempts?)\b/.test(
+        content
+      ) && /\b(?:security|auth(?:entication|orization)?|login|roles?|permissions?|password|lockout|failed)\b/.test(
+        content
+      );
+    }
+    if (isSoySauceSubstituteCountQuery(query)) {
+      return isSoySauceSubstituteEvidenceText(content);
+    }
+    return overlap >= 2 && /\b(?:confirm|verify|check|count|mention|mentioned|try|tried|want|wanted)\b/.test(
+      content
+    );
+  }
+  if (intent === "recommendation") {
+    if (isWritingPlaceRecommendationQuery(query)) {
+      return /\b(?:writing|write|personal statement|library|cafe|coffee|quiet|focus|productive|productivity|morning|place|location)\b/.test(
+        content
+      );
+    }
+    if (isSneakerFeatureRecommendationQuery(query)) {
+      return /\b(?:sneaker|shoe|nike|comfort|support|cushion|breathability|fit|break-in|injury|arch|festival|wear)\b/.test(
+        content
+      );
+    }
+    return overlap >= 2 && /\b(?:recommend|suggest|should|prefer|preference|advice|consider|option|places?|features?)\b/.test(
+      content
+    );
+  }
+  if (intent === "relation") {
+    if (isSpecialEventLocationQuery(query)) {
+      const personTerms = extractSpecialEventPersonTerms(normalizedQuery);
+      const hasPersonTerm = personTerms.length === 0 || personTerms.some((term) => content.includes(term));
+      return hasPersonTerm && /\b(?:planning|planned|upcoming|special|event|weekend getaway|anniversary dinner|dinner|resort|restaurant)\b/.test(
+        content
+      ) && /\b(?:at|to|in|resort|restaurant|venue|where|location|place)\b/.test(
+        content
+      );
+    }
+    const relationTerms = extractRelationTerms(normalizedQuery);
+    const hasRelationTerm = relationTerms.some((term) => content.includes(term));
+    return hasRelationTerm && /\b(?:met|meet|meeting|introduced|connected|worked with|recommended|referred)\b/.test(content) && /\b(?:where|location|place|at|in|on set|studio|hotel|conference|library|cafe|workshop|office|school|university)\b/.test(
+      content
+    );
+  }
+  return false;
+}
+function scoreFocusedListEvidence(item, query, intent) {
+  const content = item.content.toLowerCase();
+  let score = 0;
+  if (item.role === "user") score += intent === "count" ? 12 : 5;
+  if (item.role === "assistant") score += intent === "recommendation" ? 10 : 2;
+  score += countFocusedTermOverlap(content, query.toLowerCase()) * 2;
+  if (intent === "count") {
+    if (hasConfirmIntent(content)) score += 8;
+    if (extractProbabilityFormulas(item.content).length > 0) score += 10;
+    if (isWeatherFeatureCountQuery(query) && /\bweather app\b/.test(content)) score += 8;
+    if (isCoverLetterCountQuery(query) && /\bcover letter\b/.test(content)) score += 8;
+    if (isSecurityFeatureCountQuery(query) && /\b(?:password|role|rbac|permissions?|lockout|failed login)\b/.test(content)) {
+      score += 10;
+    }
+    if (isSoySauceSubstituteCountQuery(query) && isSoySauceSubstituteEvidenceText(content)) {
+      score += 12;
+    }
+  } else {
+    if (/\b(?:recommend|suggest|should|consider|places?|features?|tips?)\b/.test(content)) {
+      score += 7;
+    }
+    if (isWritingPlaceRecommendationQuery(query) && /\b(?:library|cafe|coffee|quiet|morning|productive)\b/.test(content)) {
+      score += 10;
+    }
+    if (isSneakerFeatureRecommendationQuery(query) && /\b(?:comfort|support|cushion|breathability|fit|break-in|injury|arch)\b/.test(content)) {
+      score += 10;
+    }
+  }
+  if (intent === "relation") {
+    if (/\b(?:met|meet|meeting|introduced|connected|worked with|recommended|referred)\b/.test(content)) {
+      score += 14;
+    }
+    if (/\b(?:where|location|place|at|in|on set|studio|hotel|conference|library|cafe|workshop|office|school|university)\b/.test(content)) {
+      score += 10;
+    }
+    if (isSpecialEventLocationQuery(query) && /\b(?:weekend getaway|anniversary dinner|resort|restaurant|venue)\b/.test(content)) {
+      score += 16;
+      if (item.role === "user") score += 14;
+      score += extractSpecialEventPersonTerms(query.toLowerCase()).filter(
+        (term) => content.includes(term)
+      ).length * 8;
+    }
+    score += extractRelationTerms(query.toLowerCase()).filter(
+      (term) => content.includes(term)
+    ).length * 6;
+  }
+  if (typeof item.score === "number" && Number.isFinite(item.score)) {
+    score += Math.min(5, Math.max(0, item.score / 20));
+  }
+  return score;
+}
+function classifyFocusedListIntent(query) {
+  const normalized = query.toLowerCase();
+  if (/\bhow many\b/.test(normalized) && /\b(?:different|times?|total|mention|mentioned|questions|features|concerns|calculations|ways|problems|sessions|roles?)\b/.test(
+    normalized
+  )) {
+    return "count";
+  }
+  if (isSpecialEventLocationQuery(normalized)) {
+    return "relation";
+  }
+  if (/\b(?:what|which|where|suggest|recommend|should|advice|features?)\b/.test(normalized) && /\b(?:places?|locations?|writing|sneakers?|shoes?|features?)\b/.test(normalized)) {
+    return "recommendation";
+  }
+  if (/\b(?:where|when|how)\b/.test(normalized) && /\b(?:met|meet|meeting|know|connected|introduced)\b/.test(normalized)) {
+    return "relation";
+  }
+  return null;
+}
+function buildFocusedListQuery(query, intent) {
+  const cues = [query, ...extractFocusedTerms(query).slice(0, 16)];
+  if (intent === "count") {
+    cues.push(
+      "count distinct mentioned confirmed verified checked tried asked wanted feature concern calculation"
+    );
+    if (isProbabilityCountQuery(query)) {
+      cues.push("coin toss dice roll probability calculation confirm verify check formula");
+    }
+    if (isWeatherFeatureCountQuery(query)) {
+      cues.push("weather app autocomplete error handling caching quota GitHub Pages HTTPS deployment");
+    }
+    if (isCoverLetterCountQuery(query)) {
+      cues.push("cover letter submit revise draft feedback interview preparation");
+    }
+    if (isSecurityFeatureCountQuery(query)) {
+      cues.push("security authentication user roles password hashing role-based access control RBAC account lockout failed login attempts");
+    }
+    if (isSoySauceSubstituteCountQuery(query)) {
+      cues.push("soy sauce substitute substitutes coconut aminos liquid aminos allergy soy-free stir-fry bought replaced");
+    }
+  } else {
+    cues.push("recommend suggest preference advice should consider features places options");
+    if (isWritingPlaceRecommendationQuery(query)) {
+      cues.push("writing morning focus quiet library cafe coffee place personal statement productivity");
+    }
+    if (isSneakerFeatureRecommendationQuery(query)) {
+      cues.push("sneaker shoe comfort support cushioning breathability fit injury arch break-in");
+    }
+  }
+  if (intent === "relation") {
+    cues.push("met where location place on set studio introduced connected recommended relationship person special events planning resort dinner restaurant");
+    if (isSpecialEventLocationQuery(query)) {
+      cues.push("weekend getaway anniversary dinner venue resort restaurant date planning");
+    }
+  }
+  return cues.join(" ");
+}
+function focusedListTitle(intent) {
+  if (intent === "count") return "Focused count evidence";
+  if (intent === "recommendation") return "Focused recommendation evidence";
+  return "Focused relation evidence";
+}
+function isProbabilityCountQuery(query) {
+  const normalized = query.toLowerCase();
+  return /\b(?:probability|calculations?)\b/.test(normalized) && /\b(?:coin|coins|tossing|toss|dice|die|rolling|roll)\b/.test(normalized);
+}
+function isWeatherFeatureCountQuery(query) {
+  const normalized = query.toLowerCase();
+  return /\bweather app\b/.test(normalized) && /\b(?:features?|concerns?|handle|wanting|wanted|mentioned)\b/.test(normalized);
+}
+function isCoverLetterCountQuery(query) {
+  const normalized = query.toLowerCase();
+  return /\bcover letter\b/.test(normalized) && /\b(?:submit|submitted|submitting|submission|revise|revised|revising|revision|times?)\b/.test(
+    normalized
+  );
+}
+function isSecurityFeatureCountQuery(query) {
+  const normalized = query.toLowerCase();
+  return /\bhow many\b/.test(normalized) && /\b(?:security|authentication|authorization|auth|user roles?|roles?|permissions?)\b/.test(normalized) && /\b(?:features?|roles?|implement|across|sessions|trying)\b/.test(normalized);
+}
+function isSoySauceSubstituteCountQuery(query) {
+  const normalized = query.toLowerCase();
+  return /\bhow many\b/.test(normalized) && /\bsoy sauce\b/.test(normalized) && /\bsubstitutes?\b/.test(normalized);
+}
+function isSoySauceSubstituteEvidenceText(content) {
+  return /\bsoy sauce\b/.test(content) && /\b(?:coconut aminos|liquid aminos)\b/.test(content) && /\b(?:substitute|replace|replaced|instead of|remov(?:e|ed|ing)|buy|buying|bought|use|using)\b/.test(
+    content
+  );
+}
+function isWritingPlaceRecommendationQuery(query) {
+  const normalized = query.toLowerCase();
+  return /\bwriting\b/.test(normalized) && /\b(?:places?|locations?|where|spend)\b/.test(normalized);
+}
+function isSneakerFeatureRecommendationQuery(query) {
+  const normalized = query.toLowerCase();
+  return /\b(?:sneakers?|shoes?)\b/.test(normalized) && /\b(?:features?|pay attention|attention|should)\b/.test(normalized);
+}
+function isSpecialEventLocationQuery(query) {
+  const normalized = query.toLowerCase();
+  return /\b(?:what|where|which)\b/.test(normalized) && /\b(?:special events?|planning with|take place|where will|events? am i planning)\b/.test(
+    normalized
+  );
+}
+function extractSpecialEventPersonTerms(text) {
+  return extractFocusedTerms(text).filter(
+    (term) => !SPECIAL_EVENT_STOP_WORDS.has(term) && term.length >= 4
+  );
+}
+function hasConfirmIntent(content) {
+  return /\b(?:confirm|verify|check|get it right|is correct|doing it right|make sure i (?:get|got|am getting|understood) it right|make sure i'm doing it right)\b/.test(
+    content
+  );
+}
+function extractProbabilityFormulas(content) {
+  const formulas = /* @__PURE__ */ new Map();
+  for (const match of content.matchAll(/\bP\s*\(([^)]{1,100})\)\s*(?:=|≈|≠)\s*([^,.;\n?]{1,120})/gi)) {
+    const event = cleanFormulaPart(match[1] ?? "");
+    const value = cleanFormulaPart(match[2] ?? "");
+    if (!event || !value) continue;
+    const formula = `P(${event}) = ${value}`;
+    formulas.set(normalizeProbabilityCandidateKey(formula), formula);
+  }
+  for (const match of content.matchAll(/\bprobability of ([^,.;?\n]{4,100})\s+(?:is|would be|=)\s+([^,.;?\n]{1,80})/gi)) {
+    const event = cleanFormulaPart(match[1] ?? "");
+    const value = cleanFormulaPart(match[2] ?? "");
+    if (!event || !value) continue;
+    const formula = `probability of ${event} = ${value}`;
+    formulas.set(normalizeProbabilityCandidateKey(formula), formula);
+  }
+  for (const match of content.matchAll(/\bP\(([^)]{1,100})\)\s+using the formula\s+([^,.;?\n]{1,100})/gi)) {
+    const event = cleanFormulaPart(match[1] ?? "");
+    const value = cleanFormulaPart(match[2] ?? "");
+    if (!event || !value) continue;
+    const formula = `P(${event}) = ${value}`;
+    formulas.set(normalizeProbabilityCandidateKey(formula), formula);
+  }
+  return [...formulas.values()];
+}
+function cleanFormulaPart(value) {
+  return value.replace(/\s+/g, " ").replace(/\s*->->.*$/g, "").replace(/\s+and\s+how\b.*$/i, "").replace(/\s+i want\b.*$/i, "").replace(/\s+as this\b.*$/i, "").trim();
+}
+function summarizeCoverLetterCandidate(content) {
+  const text = content.replace(/\s+/g, " ").replace(/\s*->->.*$/g, "").trim();
+  const clauses = text.split(/(?<=[.!?])\s+|,\s+(?=but|and|so|can|what|how)/i);
+  const focused = clauses.find(
+    (clause) => /\bcover letter\b/i.test(clause) && /\b(?:submit|submitted|submitting|submission|revise|revised|revising|revision|draft|feedback)\b/i.test(
+      clause
+    )
+  );
+  return clipSummaryLabel(focused ?? text);
+}
+function isStrictSimpleCoinDiceConfirmation(formula, content) {
+  const normalizedFormula = formula.toLowerCase();
+  const normalizedContent = content.toLowerCase();
+  if (!hasConfirmIntent(normalizedContent)) {
+    return false;
+  }
+  if (!/\b(?:heads|coin|coins|toss|tosses|rolling|roll|die|dice)\b/.test(
+    `${normalizedFormula} ${normalizedContent}`
+  )) {
+    return false;
+  }
+  if (!/=\s*(?:[^.;]*\d+\s*\/\s*\d+|0\b|[^.;]*\d+(?:\.\d+)?%)/.test(normalizedFormula)) {
+    return false;
+  }
+  if (/\b(?:first die|second die|two dice|sum of|deck|card|ace|king|queen|heart|birthday|conditional|dependent)\b/.test(normalizedFormula)) {
+    return false;
+  }
+  if (/^p\(\s*a\b/.test(normalizedFormula)) {
+    return false;
+  }
+  if (/\bnumber of problems\b/.test(normalizedContent)) {
+    return false;
+  }
+  return true;
+}
+function isStrictSimpleProbabilityLabel(label) {
+  const normalizedFormula = label.toLowerCase();
+  return /\b(?:heads|coin|coins|toss|tosses|rolling|roll|die|dice)\b/.test(
+    normalizedFormula
+  ) && /=\s*(?:[^.;]*\d+\s*\/\s*\d+|0\b|[^.;]*\d+(?:\.\d+)?%)/.test(
+    normalizedFormula
+  ) && !/\b(?:first die|second die|two dice|sum of|deck|card|ace|king|queen|heart|birthday|conditional|dependent)\b/.test(
+    normalizedFormula
+  ) && !/^p\(\s*a\b/.test(normalizedFormula);
+}
+function findTemporalCutoffTurn(items, query, cutoffPattern) {
+  if (!/\bbefore\b/i.test(query)) {
+    return void 0;
+  }
+  let cutoff;
+  for (const item of items) {
+    if (typeof item.turnIndex !== "number") continue;
+    if (!cutoffPattern.test(item.content)) continue;
+    cutoff = cutoff === void 0 ? item.turnIndex : Math.min(cutoff, item.turnIndex);
+  }
+  return cutoff;
+}
+function sortCountCandidates(left, right) {
+  const leftTurn = typeof left.turnIndex === "number" ? left.turnIndex : Number.MAX_SAFE_INTEGER;
+  const rightTurn = typeof right.turnIndex === "number" ? right.turnIndex : Number.MAX_SAFE_INTEGER;
+  if (leftTurn !== rightTurn) return leftTurn - rightTurn;
+  return left.label.localeCompare(right.label);
+}
+function clipSummaryLabel(value) {
+  const trimmed = value.trim();
+  return trimmed.length <= 180 ? trimmed : `${trimmed.slice(0, 177).trimEnd()}...`;
+}
+function normalizeCountCandidateKey(value) {
+  return value.toLowerCase().replace(/\s+/g, " ").replace(/[“”]/g, '"').replace(/[’]/g, "'").replace(/\bthe\b/g, "").replace(/\s+/g, " ").trim();
+}
+function normalizeProbabilityCandidateKey(value) {
+  return normalizeCountCandidateKey(value).replace(/\s+(?:so|because|as)\b.*$/g, "").replace(/\s+one more time\b.*$/g, "").replace(/\s+is correct\b.*$/g, "").replace(/\s+correct\b.*$/g, "").trim();
+}
+function numberWord(value) {
+  return NUMBER_WORDS[value];
+}
+function countFocusedTermOverlap(content, query) {
+  const terms = extractFocusedTerms(query);
+  let overlap = 0;
+  for (const term of terms) {
+    if (content.includes(term)) overlap += 1;
+  }
+  return overlap;
+}
+function extractFocusedTerms(text) {
+  const terms = text.toLowerCase().match(/[a-z][a-z0-9-]{2,}/g) ?? [];
+  return [...new Set(terms.filter(
+    (term) => !FOCUSED_LIST_STOP_WORDS.has(term) && !/^\d+$/.test(term)
+  ))];
+}
+function extractRelationTerms(text) {
+  return extractFocusedTerms(text).filter(
+    (term) => !RELATION_STOP_WORDS.has(term) && !/\b(?:met|meet|meeting|know|connected|introduced)\b/.test(term)
+  );
+}
+function normalizePositiveInteger(value) {
+  if (!Number.isFinite(value) || value <= 0) {
+    return 0;
+  }
+  return Math.floor(value);
+}
+function clipTextToBudget(text, maxChars) {
+  if (text.length <= maxChars) {
+    return text;
+  }
+  if (maxChars <= 3) {
+    return text.slice(0, Math.max(0, maxChars));
+  }
+  return `${text.slice(0, maxChars - 3).trimEnd()}...`;
+}
+var FOCUSED_LIST_STOP_WORDS = /* @__PURE__ */ new Set([
+  "about",
+  "across",
+  "after",
+  "also",
+  "and",
+  "are",
+  "before",
+  "between",
+  "can",
+  "could",
+  "did",
+  "different",
+  "does",
+  "for",
+  "from",
+  "have",
+  "how",
+  "into",
+  "many",
+  "mention",
+  "mentioned",
+  "next",
+  "off",
+  "pay",
+  "planning",
+  "should",
+  "some",
+  "spend",
+  "that",
+  "the",
+  "this",
+  "time",
+  "times",
+  "total",
+  "want",
+  "wanted",
+  "wanting",
+  "were",
+  "what",
+  "when",
+  "where",
+  "which",
+  "with",
+  "would",
+  "you"
+]);
+var RELATION_STOP_WORDS = /* @__PURE__ */ new Set([
+  "did",
+  "how",
+  "know",
+  "meet",
+  "met",
+  "say",
+  "saying",
+  "when",
+  "where"
+]);
+var SPECIAL_EVENT_STOP_WORDS = /* @__PURE__ */ new Set([
+  "events",
+  "event",
+  "planning",
+  "place",
+  "special",
+  "take",
+  "where",
+  "will"
+]);
+var NUMBER_WORDS = {
+  0: "zero",
+  1: "one",
+  2: "two",
+  3: "three",
+  4: "four",
+  5: "five",
+  6: "six",
+  7: "seven",
+  8: "eight",
+  9: "nine",
+  10: "ten",
+  11: "eleven",
+  12: "twelve",
+  13: "thirteen",
+  14: "fourteen",
+  15: "fifteen",
+  16: "sixteen",
+  17: "seventeen",
+  18: "eighteen",
+  19: "nineteen",
+  20: "twenty"
+};
+
+export {
+  shouldRecallFocusedListEvidence,
+  buildFocusedListRecallSection
+};
+//# sourceMappingURL=chunk-DB5A3NHS.js.map