scientify 1.12.2 → 1.13.1

package/dist/src/literature/subscription-state.js

@@ -16,6 +16,12 @@ const MAX_STRICT_FULLTEXT_ATTEMPTS = 5;
 const ARXIV_API_URL = "https://export.arxiv.org/api/query";
 const STRICT_EMPTY_FALLBACK_MAX_RESULTS = 12;
 const STRICT_EMPTY_FALLBACK_MAX_QUERIES = 4;
+const DEFAULT_STRICT_CANDIDATE_POOL = 24;
+const DEFAULT_STRICT_MIN_CORE_FLOOR = 3;
+const TIER_A_RATIO = 0.5;
+const TIER_B_RATIO = 0.35;
+const TIER_C_RATIO = 0.15;
+const REFLECTION_MAX_ADDED_PAPERS = 2;
 const FEEDBACK_SIGNAL_DELTA = {
     read: 1,
     skip: -1,
@@ -390,6 +396,98 @@ function tokenizeKeywords(raw) {
     }
     return [...seen];
 }
+function inferTopicAliases(tokens) {
+    const normalized = tokens
+        .map((token) => token.toLowerCase())
+        .filter((token) => /^[a-z][a-z0-9_-]*$/.test(token))
+        .slice(0, 6);
+    if (normalized.length < 3)
+        return [];
+    const aliases = new Set();
+    const [a, b, c] = normalized;
+    if (a.length >= 2 && b.length >= 1 && c.length >= 1) {
+        aliases.add(`${a.slice(0, 2)}${b[0]}${c[0]}`);
+    }
+    aliases.add(`${a[0]}${b[0]}${c[0]}`);
+    const hasLow = normalized.includes("low");
+    const hasRank = normalized.includes("rank");
+    const hasAdapt = normalized.some((token) => token.startsWith("adapt"));
+    if (hasLow && hasRank && hasAdapt)
+        aliases.add("lora");
+    return [...aliases].filter((alias) => alias.length >= 3 && alias.length <= 8);
+}
+function buildScoringTokens(topic) {
+    const stopwords = new Set([
+        "from",
+        "with",
+        "without",
+        "first",
+        "basics",
+        "basic",
+        "foundational",
+        "foundation",
+        "seminal",
+        "classic",
+        "avoid",
+        "benchmark",
+        "only",
+        "prefer",
+        "authoritative",
+        "latest",
+        "recent",
+        "paper",
+        "papers",
+        "study",
+        "works",
+    ]);
+    const rawTokens = tokenizeKeywords(topic);
+    const aliases = inferTopicAliases(rawTokens);
+    const base = rawTokens.filter((token) => token.length >= 4 && !stopwords.has(token));
+    if (base.length > 0)
+        return [...new Set([...base, ...aliases])].slice(0, 10);
+    return [...new Set([...rawTokens, ...aliases])].slice(0, 10);
+}
+function buildRetrievalSeedTokens(topic) {
+    const directiveWords = new Set([
+        "from",
+        "with",
+        "without",
+        "first",
+        "basics",
+        "basic",
+        "foundational",
+        "foundation",
+        "seminal",
+        "classic",
+        "avoid",
+        "benchmark",
+        "only",
+        "prefer",
+        "authoritative",
+        "latest",
+        "recent",
+        "paper",
+        "papers",
+        "study",
+        "works",
+        "strict",
+        "fast",
+    ]);
+    const rawTokens = tokenizeKeywords(topic);
+    const aliases = inferTopicAliases(rawTokens);
+    const tokens = rawTokens
+        .map((token) => token.toLowerCase())
+        .filter((token) => token.length >= 3 && !directiveWords.has(token));
+    return [...new Set([...tokens, ...aliases])].slice(0, 10);
+}
+const FOUNDATIONAL_HINT_RE = /\b(foundational|foundation|seminal|classic|groundwork|original paper|from basics|start from basics|first principles)\b|\u57fa\u7840|\u5950\u57fa|\u7ecf\u5178|\u539f\u59cb/u;
+const AVOID_BENCHMARK_HINT_RE = /\b(avoid benchmark|benchmark-only|no benchmark|less benchmark|not benchmark only)\b|\u5c11\u63a8.*benchmark|\u4e0d\u8981.*benchmark/u;
+const SURVEY_HINT_RE = /\b(survey|review|taxonomy|overview|tutorial)\b|\u7efc\u8ff0|\u8bc4\u8ff0/u;
+const AUTHORITY_HINT_RE = /\b(authoritative|high impact|top-tier|highly cited|landmark|canonical)\b|\u6743\u5a01|\u9ad8\u5f15\u7528/u;
+const RECENT_HINT_RE = /\b(latest|recent|state[- ]of[- ]the[- ]art|newest)\b|\u6700\u65b0|\u8fd1\u671f/u;
+const BENCHMARK_WORD_RE = /\b(benchmark|leaderboard|dataset|evaluation)\b/i;
+const METHOD_WORD_RE = /\b(method|approach|adaptation|training|fine[- ]?tuning|optimization|algorithm|framework|model)\b/i;
+const SURVEY_WORD_RE = /\b(survey|review|taxonomy|overview|tutorial)\b/i;
 function decodeXmlEntities(raw) {
     return raw
         .replace(/&lt;/g, "<")
@@ -426,16 +524,7 @@ function parseArxivAtomCandidates(xml) {
     }
     return parsed;
 }
-function buildStrictFallbackQueries(topic) {
-    const normalizedTopic = normalizeText(topic);
-    const queries = [normalizedTopic];
-    const tokens = tokenizeKeywords(normalizedTopic).filter((token) => token.length >= 3).slice(0, 8);
-    if (tokens.length >= 2) {
-        queries.push(tokens.join(" "));
-    }
-    if (tokens.length >= 4) {
-        queries.push(tokens.slice(0, 4).join(" "));
-    }
+function dedupeQueries(queries, limit) {
     const seen = new Set();
     const deduped = [];
     for (const query of queries) {
@@ -444,28 +533,139 @@ function buildStrictFallbackQueries(topic) {
             continue;
         seen.add(key);
         deduped.push(query);
+        if (deduped.length >= limit)
+            break;
     }
-    return deduped.slice(0, STRICT_EMPTY_FALLBACK_MAX_QUERIES);
+    return deduped;
+}
+function buildStrictFallbackQueries(topic) {
+    const seedTokens = buildRetrievalSeedTokens(topic);
+    const normalizedTopic = seedTokens.length > 0 ? seedTokens.join(" ") : normalizeText(topic);
+    const tokens = seedTokens.length > 0 ? seedTokens : tokenizeKeywords(normalizedTopic).filter((token) => token.length >= 3).slice(0, 10);
+    const queries = [normalizedTopic];
+    if (tokens.length >= 2)
+        queries.push(tokens.slice(0, 4).join(" "));
+    if (tokens.length >= 3)
+        queries.push(tokens.slice(0, 3).join(" "));
+    return dedupeQueries(queries, STRICT_EMPTY_FALLBACK_MAX_QUERIES);
+}
+function buildTieredFallbackQueries(topic) {
+    const seedTokens = buildRetrievalSeedTokens(topic);
+    const normalizedTopic = seedTokens.length > 0 ? seedTokens.join(" ") : normalizeText(topic);
+    const tokens = seedTokens.length > 0 ? seedTokens : tokenizeKeywords(normalizedTopic).filter((token) => token.length >= 3).slice(0, 10);
+    const tierA = buildStrictFallbackQueries(topic);
+    const tierB = dedupeQueries([
+        ...tokens.slice(0, 6).map((token) => `${token} adaptation`),
+        ...tokens.slice(0, 6).map((token) => `${token} method`),
+        ...tokens.slice(0, 4).map((token) => `${token} framework`),
+        tokens.slice(0, 4).join(" "),
+    ], STRICT_EMPTY_FALLBACK_MAX_QUERIES);
+    const tierC = dedupeQueries([
+        ...tokens.slice(0, 5).map((token) => `${token} transfer learning`),
+        ...tokens.slice(0, 5).map((token) => `${token} benchmark`),
+        ...tokens.slice(0, 5).map((token) => `${token} retrieval`),
+        `${normalizedTopic} cross domain`,
+    ], STRICT_EMPTY_FALLBACK_MAX_QUERIES);
+    return {
+        tierA: tierA.length > 0 ? tierA : [normalizedTopic],
+        tierB,
+        tierC,
+    };
+}
+function inferRequirementProfile(raw) {
+    const text = normalizeText(raw);
+    return {
+        foundationalFirst: FOUNDATIONAL_HINT_RE.test(text),
+        avoidBenchmarkOnly: AVOID_BENCHMARK_HINT_RE.test(text),
+        preferSurvey: SURVEY_HINT_RE.test(text),
+        preferAuthority: AUTHORITY_HINT_RE.test(text),
+        preferRecent: RECENT_HINT_RE.test(text),
+    };
+}
+function inferCandidateYear(paper) {
+    if (paper.published) {
+        const ts = Date.parse(paper.published);
+        if (Number.isFinite(ts))
+            return new Date(ts).getUTCFullYear();
+    }
+    const modern = paper.id.match(/:(\d{2})(\d{2})\./);
+    if (modern?.[1]) {
+        const yy = Number.parseInt(modern[1], 10);
+        if (Number.isFinite(yy))
+            return 2000 + yy;
+    }
+    return undefined;
+}
+function isBenchmarkOnlyPaper(paper) {
+    const text = `${paper.title} ${paper.summary ?? ""}`;
+    return BENCHMARK_WORD_RE.test(text) && !METHOD_WORD_RE.test(text);
+}
+function isSurveyPaper(paper) {
+    const text = `${paper.title} ${paper.summary ?? ""}`;
+    return SURVEY_WORD_RE.test(text);
+}
+function isFoundationalPaper(args) {
+    const year = args.year;
+    const nowYear = new Date().getUTCFullYear();
+    const oldEnough = typeof year === "number" ? year <= nowYear - 2 : false;
+    const title = normalizeText(args.paper.title).toLowerCase();
+    const tokenHit = args.topicTokens.some((token) => token.length >= 4 && title.includes(token));
+    return oldEnough || tokenHit;
 }
 function countTokenOverlap(tokens, text) {
-    const hay = ` ${normalizeText(text).toLowerCase()} `;
+    const hay = ` ${normalizeText(text)
+        .toLowerCase()
+        .replace(/[_-]+/g, " ")
+        .replace(/[^\p{L}\p{N}\s]+/gu, " ")
+        .replace(/\s+/g, " ")} `;
     let score = 0;
     for (const token of tokens) {
         if (token.length < 2)
             continue;
-        if (hay.includes(` ${token} `))
+        const normalizedToken = token
+            .toLowerCase()
+            .replace(/[_-]+/g, " ")
+            .replace(/[^\p{L}\p{N}\s]+/gu, " ")
+            .trim();
+        if (!normalizedToken)
+            continue;
+        if (hay.includes(` ${normalizedToken} `))
             score += 1;
     }
     return score;
 }
-function scoreFallbackCandidate(topicTokens, paper) {
+function scoreFallbackCandidate(topicTokens, paper, tier, requirements) {
     const titleOverlap = countTokenOverlap(topicTokens, paper.title);
     const abstractOverlap = countTokenOverlap(topicTokens, paper.summary ?? "");
     const publishedAt = paper.published ? Date.parse(paper.published) : NaN;
     const recencyBoost = Number.isFinite(publishedAt)
         ? Math.max(0, Math.min(8, (Date.now() - publishedAt) / (1000 * 60 * 60 * 24 * -180)))
         : 0;
-    const rawScore = 60 + titleOverlap * 8 + abstractOverlap * 3 + recencyBoost;
+    const tierBoost = tier === "tierA" ? 8 : tier === "tierB" ? 4 : 1;
+    const year = inferCandidateYear(paper);
+    const isBenchmarkOnly = isBenchmarkOnlyPaper(paper);
+    const isSurvey = isSurveyPaper(paper);
+    const isFoundational = isFoundationalPaper({ paper, year, topicTokens });
+    const nowYear = new Date().getUTCFullYear();
+    const recencyPenalty = typeof year === "number" && year >= nowYear ? 4 : 0;
+    let rawScore = 60 + tierBoost + titleOverlap * 8 + abstractOverlap * 3 + recencyBoost - recencyPenalty;
+    if (requirements.foundationalFirst) {
+        rawScore += isFoundational ? 10 : -4;
+    }
+    if (requirements.preferSurvey) {
+        rawScore += isSurvey ? 8 : 0;
+    }
+    if (requirements.preferAuthority) {
+        rawScore += isSurvey ? 3 : 0;
+        if (isFoundational)
+            rawScore += 2;
+    }
+    if (requirements.preferRecent && typeof year === "number" && year >= nowYear - 1) {
+        rawScore += 4;
+    }
+    if (requirements.avoidBenchmarkOnly && isBenchmarkOnly) {
+        rawScore -= 15;
+    }
     return Math.max(50, Math.min(99, Math.round(rawScore)));
 }
 async function fetchArxivFallbackByQuery(query) {
@@ -498,34 +698,139 @@ async function fetchArxivFallbackByQuery(query) {
     }
 }
 async function strictCoreFallbackSeed(args) {
-    const queries = buildStrictFallbackQueries(args.topic);
+    const tieredQueries = buildTieredFallbackQueries(args.topic);
     const byId = new Map();
     const traces = [];
-    for (const query of queries) {
-        const rows = await fetchArxivFallbackByQuery(query);
-        traces.push({
-            query,
-            reason: "strict_core_backfill_seed",
-            source: "arxiv",
-            candidates: rows.length,
-            filteredTo: rows.length,
-            resultCount: rows.length,
-        });
-        for (const row of rows) {
-            if (!byId.has(row.id))
-                byId.set(row.id, row);
+    const tierStats = {
+        tierA: { candidates: 0, selected: 0 },
+        tierB: { candidates: 0, selected: 0 },
+        tierC: { candidates: 0, selected: 0 },
+    };
+    for (const tier of ["tierA", "tierB", "tierC"]) {
+        for (const query of tieredQueries[tier]) {
+            const rows = await fetchArxivFallbackByQuery(query);
+            tierStats[tier].candidates += rows.length;
+            traces.push({
+                query,
+                reason: `strict_core_backfill_seed_${tier}`,
+                source: "arxiv",
+                candidates: rows.length,
+                filteredTo: rows.length,
+                resultCount: rows.length,
+            });
+            for (const row of rows) {
+                if (!byId.has(row.id))
+                    byId.set(row.id, { row, tier });
+            }
         }
     }
     const topicTokens = tokenizeKeywords(args.topic);
+    const scoringTokens = buildScoringTokens(args.topic);
     const ranked = [...byId.values()]
-        .map((row) => ({
-        row,
-        score: scoreFallbackCandidate(topicTokens, row),
-    }))
+        .map(({ row, tier }) => {
+        const year = inferCandidateYear(row);
+        const isSurvey = isSurveyPaper(row);
+        const isBenchmarkOnly = isBenchmarkOnlyPaper(row);
+        const isFoundational = isFoundationalPaper({ paper: row, year, topicTokens });
+        const relevance = countTokenOverlap(scoringTokens, `${row.title} ${row.summary ?? ""}`);
+        return {
+            row,
+            tier,
+            year,
+            isSurvey,
+            isBenchmarkOnly,
+            isFoundational,
+            relevance,
+            score: scoreFallbackCandidate(scoringTokens.length > 0 ? scoringTokens : topicTokens, row, tier, args.requirements),
+        };
+    })
         .sort((a, b) => b.score - a.score);
     const unseen = ranked.filter((item) => !args.knownPaperIds.has(item.row.id));
-    const effectivePool = unseen.length > 0 ? unseen : ranked;
-    const selected = effectivePool.slice(0, Math.max(1, Math.min(10, args.maxPapers)));
+    const poolBeforeRelevance = unseen.length > 0 ? unseen : ranked;
+    const minRelevance = scoringTokens.length >= 2 ? 2 : 1;
+    const candidatePool = Math.max(1, Math.min(40, Math.floor(args.candidatePool ?? Math.max(DEFAULT_STRICT_CANDIDATE_POOL, args.maxPapers * 4))));
+    const minCoreFloor = Math.max(1, Math.min(args.maxPapers, args.minCoreFloor ?? DEFAULT_STRICT_MIN_CORE_FLOOR));
+    const effectivePoolByRelevance = poolBeforeRelevance.filter((item) => item.relevance >= minRelevance);
+    const focusTokens = scoringTokens.filter((token) => token.length >= 5);
+    const weakRelevanceWithFocusPool = poolBeforeRelevance.filter((item) => {
+        if (item.relevance < 1)
+            return false;
+        if (focusTokens.length === 0)
+            return true;
+        const focusHit = countTokenOverlap(focusTokens, `${item.row.title} ${item.row.summary ?? ""}`);
+        return focusHit >= 1;
+    });
+    const weakRelevancePool = weakRelevanceWithFocusPool.length > 0
+        ? weakRelevanceWithFocusPool
+        : poolBeforeRelevance.filter((item) => item.relevance >= 1);
+    const effectivePool = effectivePoolByRelevance.length >= minCoreFloor
+        ? effectivePoolByRelevance
+        : weakRelevancePool.length > 0
+            ? weakRelevancePool
+            : poolBeforeRelevance;
+    const targetCount = Math.max(minCoreFloor, Math.min(args.maxPapers, candidatePool));
+    const tierTargets = {
+        tierA: Math.max(1, Math.round(targetCount * TIER_A_RATIO)),
+        tierB: Math.max(1, Math.round(targetCount * TIER_B_RATIO)),
+        tierC: Math.max(0, targetCount - Math.round(targetCount * TIER_A_RATIO) - Math.round(targetCount * TIER_B_RATIO)),
+    };
+    if (tierTargets.tierA + tierTargets.tierB + tierTargets.tierC < targetCount) {
+        tierTargets.tierA += targetCount - (tierTargets.tierA + tierTargets.tierB + tierTargets.tierC);
+    }
+    const selected = [];
+    const selectedIds = new Set();
+    for (const tier of ["tierA", "tierB", "tierC"]) {
+        const picked = effectivePool
+            .filter((item) => item.tier === tier && !selectedIds.has(item.row.id))
+            .slice(0, tierTargets[tier]);
+        for (const item of picked) {
+            selected.push(item);
+            selectedIds.add(item.row.id);
+            tierStats[tier].selected += 1;
+        }
+    }
+    if (selected.length < targetCount) {
+        const fill = effectivePool.filter((item) => !selectedIds.has(item.row.id)).slice(0, targetCount - selected.length);
+        for (const item of fill) {
+            selected.push(item);
+            selectedIds.add(item.row.id);
+            tierStats[item.tier].selected += 1;
+        }
+    }
+    const ensureAtLeast = (predicate, need) => {
+        while (selected.filter(predicate).length < need) {
+            const candidate = effectivePool.find((item) => !selectedIds.has(item.row.id) && predicate(item));
+            if (!candidate)
+                break;
+            const replaceIndex = selected.findIndex((item) => !predicate(item));
+            if (replaceIndex < 0)
+                break;
+            selectedIds.delete(selected[replaceIndex].row.id);
+            selected[replaceIndex] = candidate;
+            selectedIds.add(candidate.row.id);
+        }
+    };
+    if (args.requirements.foundationalFirst) {
+        ensureAtLeast((item) => item.isFoundational, Math.min(2, targetCount));
+    }
+    if (args.requirements.preferSurvey) {
+        ensureAtLeast((item) => item.isSurvey, 1);
+    }
+    if (args.requirements.avoidBenchmarkOnly) {
+        for (let i = 0; i < selected.length; i += 1) {
+            if (!selected[i].isBenchmarkOnly)
+                continue;
+            const replacement = effectivePool.find((item) => !selectedIds.has(item.row.id) && !item.isBenchmarkOnly);
+            if (!replacement)
+                break;
+            selectedIds.delete(selected[i].row.id);
+            selected[i] = replacement;
+            selectedIds.add(replacement.row.id);
+        }
+    }
+    tierStats.tierA.selected = selected.filter((item) => item.tier === "tierA").length;
+    tierStats.tierB.selected = selected.filter((item) => item.tier === "tierB").length;
+    tierStats.tierC.selected = selected.filter((item) => item.tier === "tierC").length;
     const papers = selected.map(({ row, score }) => ({
         id: row.id,
         title: row.title,
@@ -550,7 +855,233 @@ async function strictCoreFallbackSeed(args) {
         papers,
         corePapers,
         explorationTrace: traces,
-        notes: `strict_core_backfill_seed selected=${selected.length} queries=${queries.length}`,
+        notes: `strict_core_backfill_seed selected=${selected.length} pool=${candidatePool} floor=${minCoreFloor} relevance_floor=${minRelevance} req_foundational=${args.requirements.foundationalFirst} req_avoid_benchmark=${args.requirements.avoidBenchmarkOnly} req_survey=${args.requirements.preferSurvey}`,
+        recallTierStats: tierStats,
+    };
+}
+function isPaperFullTextRead(paper) {
+    return paper.fullTextRead === true || paper.readStatus === "fulltext";
+}
+function hasStrictEvidenceAnchor(paper) {
+    const anchors = paper.evidenceAnchors ?? [];
+    return anchors.some((anchor) => Boolean(anchor?.section?.trim()) &&
+        Boolean(anchor?.locator?.trim()) &&
+        Boolean(anchor?.quote?.trim()));
+}
+function firstNonEmptyText(values) {
+    for (const value of values) {
+        if (typeof value !== "string")
+            continue;
+        const normalized = normalizeText(value);
+        if (normalized.length > 0)
+            return normalized;
+    }
+    return undefined;
+}
+function toEvidencePaperId(paper) {
+    return derivePaperId({ id: paper.id, title: paper.title, url: paper.url });
+}
+function dedupeEvidenceIds(ids) {
+    const seen = new Set();
+    const out = [];
+    for (const id of ids) {
+        const normalized = normalizeText(id);
+        if (!normalized)
+            continue;
+        const key = normalized.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(normalized);
+    }
+    return out;
+}
+function applyLightweightEvidenceBinding(args) {
+    if (!args.knowledgeState) {
+        return { knowledgeState: args.knowledgeState, anchorsAdded: 0, evidenceIdsFilled: 0 };
+    }
+    const corePapers = args.knowledgeState.corePapers ?? [];
+    if (corePapers.length === 0) {
+        return { knowledgeState: args.knowledgeState, anchorsAdded: 0, evidenceIdsFilled: 0 };
+    }
+    let anchorsAdded = 0;
+    const nextCore = corePapers.map((paper) => {
+        if (!isPaperFullTextRead(paper))
+            return paper;
+        if (hasStrictEvidenceAnchor(paper))
+            return paper;
+        const quote = firstNonEmptyText([
+            paper.keyEvidenceSpans?.[0],
+            paper.summary,
+            paper.reason,
+            paper.title,
+        ]);
+        if (!quote)
+            return paper;
+        const nextQuote = quote.slice(0, 260);
+        anchorsAdded += 1;
+        return {
+            ...paper,
+            evidenceAnchors: [
+                ...(paper.evidenceAnchors ?? []),
+                {
+                    section: "AutoExtract",
+                    locator: paper.fullTextRef?.trim() || "excerpt:1",
+                    claim: firstNonEmptyText([paper.researchGoal, paper.reason, paper.title, "auto-bound claim"]) ?? "auto-bound claim",
+                    quote: nextQuote,
+                },
+            ],
+        };
+    });
+    const fallbackEvidenceIds = dedupeEvidenceIds(nextCore.filter((paper) => isPaperFullTextRead(paper)).map((paper) => toEvidencePaperId(paper)).slice(0, 2));
+    let evidenceIdsFilled = 0;
+    const patchEvidenceIds = (raw, allowAuto = true) => {
+        const existing = dedupeEvidenceIds(raw ?? []);
+        if (existing.length > 0)
+            return existing;
+        if (!allowAuto || fallbackEvidenceIds.length === 0)
+            return undefined;
+        evidenceIdsFilled += 1;
+        return [...fallbackEvidenceIds];
+    };
+    const nextKnowledgeChanges = (args.knowledgeState.knowledgeChanges ?? []).map((change) => ({
+        ...change,
+        ...(change.type === "BRIDGE"
+            ? { evidenceIds: patchEvidenceIds(change.evidenceIds, false) }
+            : { evidenceIds: patchEvidenceIds(change.evidenceIds, true) }),
+    }));
+    const nextKnowledgeUpdates = (args.knowledgeState.knowledgeUpdates ?? []).map((update) => ({
+        ...update,
+        evidenceIds: patchEvidenceIds(update.evidenceIds, true),
+    }));
+    const nextHypotheses = (args.knowledgeState.hypotheses ?? []).map((hypothesis) => ({
+        ...hypothesis,
+        evidenceIds: patchEvidenceIds(hypothesis.evidenceIds, true),
+    }));
+    if (anchorsAdded === 0 && evidenceIdsFilled === 0) {
+        return { knowledgeState: args.knowledgeState, anchorsAdded: 0, evidenceIdsFilled: 0 };
+    }
+    const existingRunLog = args.knowledgeState.runLog;
+    const runLog = existingRunLog || args.runProfile
+        ? {
+            ...(existingRunLog ?? {}),
+            ...(existingRunLog?.runProfile ? {} : args.runProfile ? { runProfile: args.runProfile } : {}),
+            notes: [existingRunLog?.notes, `auto_evidence_binding anchors_added=${anchorsAdded} ids_filled=${evidenceIdsFilled}`]
+                .filter((item) => Boolean(item && item.trim().length > 0))
+                .join(" || "),
+        }
+        : undefined;
+    return {
+        knowledgeState: {
+            ...args.knowledgeState,
+            corePapers: nextCore,
+            ...(nextKnowledgeChanges.length > 0 ? { knowledgeChanges: nextKnowledgeChanges } : {}),
+            ...(nextKnowledgeUpdates.length > 0 ? { knowledgeUpdates: nextKnowledgeUpdates } : {}),
+            ...(nextHypotheses.length > 0 ? { hypotheses: nextHypotheses } : {}),
+            ...(runLog ? { runLog } : {}),
+        },
+        anchorsAdded,
+        evidenceIdsFilled,
+    };
+}
+function buildReflectionFollowupQuery(topic, hint) {
+    const tokens = tokenizeKeywords(`${topic} ${hint}`).slice(0, 8);
+    if (tokens.length === 0)
+        return normalizeText(topic);
+    return tokens.join(" ");
+}
+function resolveSingleStepReflectionSeed(args) {
+    const changes = args.knowledgeState?.knowledgeChanges ?? [];
+    const bridgeChanges = changes.filter((item) => item.type === "BRIDGE");
+    const newChanges = changes.filter((item) => item.type === "NEW");
+    const reviseChanges = changes.filter((item) => item.type === "REVISE");
+    const unreadCore = (args.knowledgeState?.corePapers ?? []).filter((paper) => !isPaperFullTextRead(paper));
+    if (bridgeChanges.length > 0) {
+        const seed = bridgeChanges[0]?.statement ?? args.topic;
+        return {
+            trigger: "BRIDGE",
+            reason: "bridge_followup",
+            query: buildReflectionFollowupQuery(args.topic, seed),
+        };
+    }
+    if (newChanges.length >= 2 && reviseChanges.length >= 1) {
+        const seed = `${newChanges[0]?.statement ?? ""} ${reviseChanges[0]?.statement ?? ""}`.trim();
+        return {
+            trigger: "CONFLICT",
+            reason: "new_revise_followup",
+            query: buildReflectionFollowupQuery(args.topic, seed || args.topic),
+        };
+    }
+    if (unreadCore.length > 0) {
+        const seed = unreadCore[0]?.id ?? unreadCore[0]?.title ?? args.topic;
+        return {
+            trigger: "UNREAD_CORE",
+            reason: "unread_core_followup",
+            query: buildReflectionFollowupQuery(args.topic, seed),
+        };
+    }
+    return undefined;
+}
+async function executeSingleStepReflection(args) {
+    const seed = resolveSingleStepReflectionSeed({
+        topic: args.topic,
+        knowledgeState: args.knowledgeState,
+    });
+    if (!seed) {
+        return {
+            executed: false,
+            resultCount: 0,
+            papers: [],
+            changes: [],
+        };
+    }
+    const rows = await fetchArxivFallbackByQuery(seed.query);
+    const localKnownIds = new Set(args.knownPaperIds);
+    for (const paper of args.effectivePapers) {
+        localKnownIds.add(derivePaperId(paper));
+    }
+    for (const paper of args.knowledgeState?.corePapers ?? []) {
+        localKnownIds.add(derivePaperId({ id: paper.id, title: paper.title, url: paper.url }));
+    }
+    for (const paper of args.knowledgeState?.explorationPapers ?? []) {
+        localKnownIds.add(derivePaperId({ id: paper.id, title: paper.title, url: paper.url }));
+    }
+    const selected = rows.filter((row) => !localKnownIds.has(row.id)).slice(0, REFLECTION_MAX_ADDED_PAPERS);
+    const papers = selected.map((row) => ({
+        id: row.id,
+        title: row.title,
+        url: row.url,
+        source: "arxiv",
+        ...(row.published ? { publishedAt: row.published } : {}),
+        ...(row.summary ? { summary: row.summary } : {}),
+        fullTextRead: false,
+        readStatus: "metadata",
+        unreadReason: "single_step_reflection_added_without_fulltext",
+    }));
+    const changes = selected.length > 0
+        ? [
+            {
+                type: "NEW",
+                statement: `Reflection follow-up added ${selected.length} adjacent paper(s) for ${args.topic}.`,
+                evidenceIds: selected.map((row) => row.id).slice(0, 3),
+                topic: args.topic,
+            },
+        ]
+        : [];
+    return {
+        executed: true,
+        resultCount: selected.length,
+        trace: {
+            query: seed.query,
+            reason: seed.reason,
+            source: "arxiv",
+            candidates: rows.length,
+            filteredTo: selected.length,
+            ...(selected.length === 0 ? { filteredOutReasons: ["no_unseen_reflection_candidates"] } : {}),
+            resultCount: selected.length,
+        },
+        papers,
+        changes,
     };
 }
 function dedupePaperRecords(records) {
@@ -943,7 +1474,7 @@ export async function recordIncrementalPush(args) {
             effectiveRunLog.requiredCorePapers = Math.max(1, requiredCoreRaw);
         }
         else {
-            delete effectiveRunLog.requiredCorePapers;
+            effectiveRunLog.requiredCorePapers = Math.max(1, Math.min(topicState.preferences.maxPapers, DEFAULT_STRICT_MIN_CORE_FLOOR));
         }
         if (typeof effectiveRunLog.requiredFullTextCoveragePct !== "number" ||
             !Number.isFinite(effectiveRunLog.requiredFullTextCoveragePct) ||
@@ -957,8 +1488,18 @@ export async function recordIncrementalPush(args) {
             ...(effectiveRunLog ? { runLog: effectiveRunLog } : {}),
         }
         : undefined;
+    const requirementProfile = inferRequirementProfile([
+        topicState.topic,
+        args.note,
+        effectiveRunLog?.notes,
+        effectiveKnowledgeState?.runLog?.notes,
+    ]
+        .filter((item) => Boolean(item && item.trim().length > 0))
+        .join(" "));
     if (incomingRunProfile === "strict") {
-        const requiredCoreFloor = Math.max(1, Math.min(topicState.preferences.maxPapers, effectiveRunLog?.requiredCorePapers ?? Math.min(3, topicState.preferences.maxPapers)));
+        const strictMinCoreFloor = Math.max(1, Math.min(topicState.preferences.maxPapers, DEFAULT_STRICT_MIN_CORE_FLOOR));
+        const requiredCoreFloor = Math.max(1, Math.min(topicState.preferences.maxPapers, effectiveRunLog?.requiredCorePapers ?? strictMinCoreFloor));
+        const strictCandidatePool = Math.max(DEFAULT_STRICT_CANDIDATE_POOL, topicState.preferences.maxPapers * 4);
         const existingCorePapers = effectiveKnowledgeState?.corePapers ?? [];
         const strictSignalCount = Math.max(existingCorePapers.length, effectivePapers.length);
         if (strictSignalCount < requiredCoreFloor) {
@@ -970,8 +1511,11 @@ export async function recordIncrementalPush(args) {
             }
             const fallback = await strictCoreFallbackSeed({
                 topic: topicState.topic,
-                maxPapers: requiredCoreFloor,
+                maxPapers: topicState.preferences.maxPapers,
+                candidatePool: strictCandidatePool,
+                minCoreFloor: requiredCoreFloor,
                 knownPaperIds: knownIds,
+                requirements: requirementProfile,
             });
             if (fallback.papers.length > 0) {
                 const existingIds = new Set(effectivePapers.map((paper) => derivePaperId(paper)));
@@ -987,6 +1531,7 @@ export async function recordIncrementalPush(args) {
                 effectivePapers = dedupePaperRecords([...effectivePapers, ...fallbackPapers]);
                 const mergedRunLog = {
                     ...(effectiveRunLog ?? { runProfile: "strict" }),
+                    recallTierStats: fallback.recallTierStats,
                     notes: [
                         effectiveRunLog?.notes,
                         fallback.notes,
@@ -1050,6 +1595,74 @@ export async function recordIncrementalPush(args) {
             };
         }
     }
+    const reflection = await executeSingleStepReflection({
+        topic: topicState.topic,
+        knownPaperIds: new Set(Object.keys(topicState.pushedPapers)),
+        effectivePapers,
+        knowledgeState: effectiveKnowledgeState,
+    });
+    const reflectionRunLogBase = effectiveRunLog ??
+        (incomingRunProfile ? { runProfile: incomingRunProfile } : undefined);
+    if (reflection.executed) {
+        const reflectionPaperRecords = reflection.papers.map((paper) => ({
+            ...(paper.id ? { id: paper.id } : {}),
+            ...(paper.title ? { title: paper.title } : {}),
+            ...(paper.url ? { url: paper.url } : {}),
+            ...(typeof paper.score === "number" && Number.isFinite(paper.score) ? { score: paper.score } : {}),
+            reason: "single_step_reflection_followup",
+        }));
+        effectivePapers = dedupePaperRecords([...effectivePapers, ...reflectionPaperRecords]);
+        const mergedRunLog = {
+            ...(reflectionRunLogBase ?? {}),
+            reflectionStepExecuted: true,
+            reflectionStepResultCount: reflection.resultCount,
+            notes: [
+                reflectionRunLogBase?.notes,
+                `single_step_reflection result_count=${reflection.resultCount}`,
+            ]
+                .filter((item) => Boolean(item && item.trim().length > 0))
+                .join(" || "),
+        };
+        effectiveRunLog = mergedRunLog;
+        effectiveKnowledgeState = {
+            ...(effectiveKnowledgeState ?? {}),
+            explorationTrace: [
+                ...(effectiveKnowledgeState?.explorationTrace ?? []),
+                ...(reflection.trace ? [reflection.trace] : []),
+            ],
+            explorationPapers: dedupeKnowledgePapers([
+                ...(effectiveKnowledgeState?.explorationPapers ?? []),
+                ...reflection.papers,
+            ]),
+            knowledgeChanges: [
+                ...(effectiveKnowledgeState?.knowledgeChanges ?? []),
+                ...(reflection.changes ?? []),
+            ],
+            runLog: mergedRunLog,
+        };
+    }
+    else if (reflectionRunLogBase) {
+        const mergedRunLog = {
+            ...reflectionRunLogBase,
+            reflectionStepExecuted: false,
+            reflectionStepResultCount: 0,
+        };
+        effectiveRunLog = mergedRunLog;
+        effectiveKnowledgeState = {
+            ...(effectiveKnowledgeState ?? {}),
+            runLog: mergedRunLog,
+        };
+    }
+    const autoEvidence = applyLightweightEvidenceBinding({
+        knowledgeState: effectiveKnowledgeState,
+        runProfile: incomingRunProfile,
+    });
+    effectiveKnowledgeState = autoEvidence.knowledgeState;
+    if (autoEvidence.anchorsAdded > 0 || autoEvidence.evidenceIdsFilled > 0) {
+        effectiveRunLog = effectiveKnowledgeState?.runLog
+            ? { ...effectiveKnowledgeState.runLog }
+            : effectiveRunLog;
+    }
     const statusRaw = normalizeText(args.status ?? "").toLowerCase();
     const researchArtifactsCount = effectivePapers.length +
         (effectiveKnowledgeState?.explorationPapers?.length ?? 0) +