scientify 1.13.5 → 2.0.0

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

@@ -9,19 +9,6 @@ const DEFAULT_SOURCES = ["openalex", "arxiv"];
 const MAX_MEMORY_NOTES = 30;
 const MAX_MEMORY_KEYS = 60;
 const TOP_HINT_LIMIT = 8;
-const DEFAULT_FULLTEXT_FETCH_TIMEOUT_MS = 20_000;
-const RETRY_FULLTEXT_FETCH_TIMEOUT_MS = 35_000;
-const MIN_FULLTEXT_TEXT_CHARS = 2_000;
-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,
@@ -184,201 +171,6 @@ function derivePaperId(paper) {
     const digest = createHash("sha1").update(fallback || JSON.stringify(paper)).digest("hex");
     return `hash:${digest.slice(0, 20)}`;
 }
-function normalizeArxivToken(token) {
-    const cleaned = normalizeText(token).replace(/^arxiv:/i, "");
-    if (!cleaned)
-        return undefined;
-    const modern = cleaned.match(/^(\d{4}\.\d{4,5}(?:v\d+)?)$/i);
-    if (modern?.[1])
-        return modern[1].toLowerCase();
-    const legacy = cleaned.match(/^([a-z\-]+(?:\.[a-z\-]+)?\/\d{7}(?:v\d+)?)$/i);
-    if (legacy?.[1])
-        return legacy[1].toLowerCase();
-    return undefined;
-}
-function stripArxivVersion(id) {
-    return id.replace(/v\d+$/i, "");
-}
-function parseArxivIdCandidatesFromPaper(paper) {
-    const candidates = [];
-    const pushToken = (value) => {
-        if (!value)
-            return;
-        const normalized = normalizeArxivToken(value);
-        if (normalized)
-            candidates.push(normalized);
-    };
-    pushToken(paper.id);
-    const combined = [paper.url, paper.title].filter((item) => Boolean(item)).join(" ");
-    for (const m of combined.matchAll(/\b(\d{4}\.\d{4,5}(?:v\d+)?)\b/gi)) {
-        pushToken(m[1]);
-    }
-    for (const m of combined.matchAll(/\b([a-z\-]+(?:\.[a-z\-]+)?\/\d{7}(?:v\d+)?)\b/gi)) {
-        pushToken(m[1]);
-    }
-    const expanded = [];
-    const seen = new Set();
-    for (const item of candidates) {
-        if (!seen.has(item)) {
-            seen.add(item);
-            expanded.push(item);
-        }
-        const base = stripArxivVersion(item);
-        if (!seen.has(base)) {
-            seen.add(base);
-            expanded.push(base);
-        }
-    }
-    return expanded;
-}
-function htmlToPlainText(html) {
-    return html
-        .replace(/<script[\s\S]*?<\/script>/gi, " ")
-        .replace(/<style[\s\S]*?<\/style>/gi, " ")
-        .replace(/<noscript[\s\S]*?<\/noscript>/gi, " ")
-        .replace(/<svg[\s\S]*?<\/svg>/gi, " ")
-        .replace(/<math[\s\S]*?<\/math>/gi, " ")
-        .replace(/<\/?(?:p|div|section|article|h\d|li|ul|ol|br|tr|td|th|table|blockquote)[^>]*>/gi, "\n")
-        .replace(/<[^>]+>/g, " ")
-        .replace(/&nbsp;/gi, " ")
-        .replace(/&amp;/gi, "&")
-        .replace(/&lt;/gi, "<")
-        .replace(/&gt;/gi, ">")
-        .replace(/&quot;/gi, "\"")
-        .replace(/&#39;/gi, "'")
-        .replace(/\r/g, "")
-        .replace(/[ \t]+\n/g, "\n")
-        .replace(/\n{3,}/g, "\n\n")
-        .replace(/[ \t]{2,}/g, " ")
-        .trim();
-}
-async function fetchArxivFullTextByHtmlCandidates(arxivIds, timeoutMs) {
-    const candidates = [];
-    const seen = new Set();
-    for (const id of arxivIds) {
-        const normalized = normalizeArxivToken(id);
-        if (!normalized)
-            continue;
-        for (const host of ["https://arxiv.org/html", "https://ar5iv.org/html"]) {
-            const url = `${host}/${normalized}`;
-            if (seen.has(url))
-                continue;
-            seen.add(url);
-            candidates.push({ url, tag: host.includes("ar5iv") ? "ar5iv_html" : "arxiv_html" });
-        }
-    }
-    const errors = [];
-    for (const candidate of candidates) {
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), timeoutMs);
-        try {
-            const res = await fetch(candidate.url, {
-                signal: controller.signal,
-                headers: {
-                    "User-Agent": "scientify-fulltext-bootstrap/1.0",
-                },
-            });
-            if (!res.ok) {
-                errors.push(`${candidate.tag}:http_${res.status}`);
-                continue;
-            }
-            const rawHtml = await res.text();
-            const plain = htmlToPlainText(rawHtml);
-            if (plain.length < MIN_FULLTEXT_TEXT_CHARS) {
-                errors.push(`${candidate.tag}:content_too_short(${plain.length})`);
-                continue;
-            }
-            return {
-                ok: true,
-                sourceUrl: candidate.url,
-                sourceTag: candidate.tag,
-                plainText: plain,
-            };
-        }
-        catch (error) {
-            errors.push(`${candidate.tag}:${error instanceof Error ? error.name || error.message : "fetch_failed"}`);
-        }
-        finally {
-            clearTimeout(timer);
-        }
-    }
-    return {
-        ok: false,
-        reason: errors.length > 0 ? errors.join(";") : "html_fulltext_unavailable",
-    };
-}
-async function backfillStrictCoreFullText(args) {
-    const updated = [];
-    let attempted = 0;
-    let completed = 0;
-    const failures = [];
-    for (const paper of args.corePapers) {
-        if (paper.fullTextRead === true || paper.readStatus === "fulltext") {
-            updated.push(paper);
-            continue;
-        }
-        const arxivIds = parseArxivIdCandidatesFromPaper({
-            id: paper.id,
-            url: paper.url,
-            title: paper.title,
-        });
-        if (arxivIds.length === 0) {
-            updated.push({
-                ...paper,
-                fullTextRead: false,
-                readStatus: paper.readStatus ?? "metadata",
-                unreadReason: paper.unreadReason ??
-                    "Automatic full-text bootstrap currently supports arXiv papers with parseable IDs only.",
-            });
-            continue;
-        }
-        if (attempted >= args.maxAttempts) {
-            updated.push({
-                ...paper,
-                fullTextRead: false,
-                readStatus: paper.readStatus ?? "metadata",
-                unreadReason: paper.unreadReason ?? "Full-text bootstrap attempt budget reached in this run.",
-            });
-            continue;
-        }
-        attempted += 1;
-        let fetched = await fetchArxivFullTextByHtmlCandidates(arxivIds, DEFAULT_FULLTEXT_FETCH_TIMEOUT_MS);
-        if (!fetched.ok) {
-            fetched = await fetchArxivFullTextByHtmlCandidates(arxivIds, RETRY_FULLTEXT_FETCH_TIMEOUT_MS);
-        }
-        if (!fetched.ok) {
-            failures.push(`${arxivIds[0]}:${fetched.reason}`);
-            updated.push({
-                ...paper,
-                fullTextRead: false,
-                readStatus: paper.readStatus ?? "metadata",
-                unreadReason: paper.unreadReason ?? `Automatic full-text fetch failed: ${fetched.reason}`,
-            });
-            continue;
-        }
-        completed += 1;
-        const excerpt = fetched.plainText.slice(0, 360).replace(/\s+/g, " ").trim();
-        updated.push({
-            ...paper,
-            fullTextRead: true,
-            readStatus: "fulltext",
-            fullTextSource: fetched.sourceTag,
-            fullTextRef: fetched.sourceUrl,
-            unreadReason: undefined,
-            ...(paper.keyEvidenceSpans && paper.keyEvidenceSpans.length > 0
-                ? {}
-                : excerpt.length > 0
-                    ? { keyEvidenceSpans: [excerpt] }
-                    : {}),
-        });
-    }
-    return {
-        corePapers: updated,
-        attempted,
-        completed,
-        failures,
-    };
-}
 function sanitizeKeyword(raw) {
     const normalized = normalizeText(raw).toLowerCase();
     if (normalized.length < 2 || normalized.length > 48)
@@ -396,741 +188,6 @@ 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, "<")
-        .replace(/&gt;/g, ">")
-        .replace(/&amp;/g, "&")
-        .replace(/&quot;/g, "\"")
-        .replace(/&apos;/g, "'");
-}
-function stripXmlTag(raw, tag) {
-    const match = raw.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`, "i"));
-    if (!match?.[1])
-        return "";
-    return normalizeText(decodeXmlEntities(match[1].replace(/<[^>]+>/g, " ").trim()));
-}
-function parseArxivAtomCandidates(xml) {
-    const entries = xml.match(/<entry>([\s\S]*?)<\/entry>/gi) ?? [];
-    const parsed = [];
-    for (const entryRaw of entries) {
-        const title = stripXmlTag(entryRaw, "title");
-        const summary = stripXmlTag(entryRaw, "summary");
-        const idUrl = stripXmlTag(entryRaw, "id");
-        const published = stripXmlTag(entryRaw, "published");
-        const arxivCandidates = parseArxivIdCandidatesFromPaper({ id: idUrl, url: idUrl, title });
-        const arxivId = arxivCandidates[0];
-        if (!title || !arxivId)
-            continue;
-        parsed.push({
-            id: `arxiv:${stripArxivVersion(arxivId)}`,
-            title,
-            summary,
-            url: `https://arxiv.org/abs/${stripArxivVersion(arxivId)}`,
-            ...(published ? { published } : {}),
-        });
-    }
-    return parsed;
-}
-function dedupeQueries(queries, limit) {
-    const seen = new Set();
-    const deduped = [];
-    for (const query of queries) {
-        const key = normalizeText(query).toLowerCase();
-        if (!key || seen.has(key))
-            continue;
-        seen.add(key);
-        deduped.push(query);
-        if (deduped.length >= limit)
-            break;
-    }
-    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()
-        .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;
-        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, 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 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) {
-    const params = new URLSearchParams({
-        search_query: query,
-        start: "0",
-        max_results: String(STRICT_EMPTY_FALLBACK_MAX_RESULTS),
-        sortBy: "relevance",
-        sortOrder: "descending",
-    });
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), 15_000);
-    try {
-        const res = await fetch(`${ARXIV_API_URL}?${params.toString()}`, {
-            signal: controller.signal,
-            headers: {
-                "User-Agent": "scientify-empty-fallback/1.0",
-            },
-        });
-        if (!res.ok)
-            return [];
-        const xml = await res.text();
-        return parseArxivAtomCandidates(xml);
-    }
-    catch {
-        return [];
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}
-async function strictCoreFallbackSeed(args) {
-    const tieredQueries = buildTieredFallbackQueries(args.topic);
-    const byId = new Map();
-    const traces = [];
-    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, 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 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,
-        url: row.url,
-        score,
-        reason: "auto_seeded_fallback_after_sparse_core_strict_run",
-    }));
-    const corePapers = selected.map(({ row, score }) => ({
-        id: row.id,
-        title: row.title,
-        url: row.url,
-        source: "arxiv",
-        ...(row.published ? { publishedAt: row.published } : {}),
-        score,
-        reason: "auto_seeded_fallback_after_sparse_core_strict_run",
-        ...(row.summary ? { summary: row.summary } : {}),
-        fullTextRead: false,
-        readStatus: "metadata",
-        unreadReason: "Auto-seeded fallback candidate; full-text bootstrap pending.",
-    }));
-    return {
-        papers,
-        corePapers,
-        explorationTrace: traces,
-        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) {
-    const byId = new Map();
-    for (const record of records) {
-        const id = derivePaperId(record);
-        const existing = byId.get(id);
-        if (!existing) {
-            byId.set(id, { ...record, ...(record.id ? {} : { id }) });
-            continue;
-        }
-        byId.set(id, {
-            id: existing.id ?? record.id ?? id,
-            title: existing.title ?? record.title,
-            url: existing.url ?? record.url,
-            score: typeof existing.score === "number" && Number.isFinite(existing.score)
-                ? typeof record.score === "number" && Number.isFinite(record.score)
-                    ? Math.max(existing.score, record.score)
-                    : existing.score
-                : record.score,
-            reason: existing.reason ?? record.reason,
-        });
-    }
-    return [...byId.values()];
-}
-function dedupeKnowledgePapers(records) {
-    const byId = new Map();
-    for (const record of records) {
-        const id = derivePaperId({ id: record.id, title: record.title, url: record.url });
-        const existing = byId.get(id);
-        if (!existing) {
-            byId.set(id, {
-                ...record,
-                ...(record.id ? {} : { id }),
-            });
-            continue;
-        }
-        byId.set(id, {
-            ...existing,
-            ...record,
-            id: existing.id ?? record.id ?? id,
-            title: existing.title ?? record.title,
-            url: existing.url ?? record.url,
-            summary: existing.summary ?? record.summary,
-            unreadReason: existing.unreadReason ?? record.unreadReason,
-        });
-    }
-    return [...byId.values()];
-}
 function normalizeSource(raw) {
     if (!raw)
         return undefined;
@@ -1445,243 +502,8 @@ export async function recordIncrementalPush(args) {
     const topicState = getOrCreateTopicState(root, args.scope, args.topic, args.preferences);
     const memory = ensureTopicMemoryState(topicState);
     const now = Date.now();
-    const normalizedPapersFromKnowledgeState = (args.knowledgeState?.corePapers ?? [])
-        .filter((paper) => paper && typeof paper === "object")
-        .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 } : {}),
-        ...(paper.reason ? { reason: paper.reason } : {}),
-    }));
-    let effectivePapers = args.papers.length > 0
-        ? args.papers
-        : normalizedPapersFromKnowledgeState.length > 0
-            ? normalizedPapersFromKnowledgeState
-            : [];
-    const incomingRunLog = args.knowledgeState?.runLog
-        ? { ...args.knowledgeState.runLog }
-        : undefined;
-    const incomingRunProfile = incomingRunLog?.runProfile === "fast" || incomingRunLog?.runProfile === "strict"
-        ? incomingRunLog.runProfile
-        : undefined;
-    let effectiveRunLog = incomingRunLog ? { ...incomingRunLog } : undefined;
-    if (incomingRunProfile === "strict" && effectiveRunLog) {
-        const requiredCoreRaw = typeof effectiveRunLog.requiredCorePapers === "number" && Number.isFinite(effectiveRunLog.requiredCorePapers)
-            ? Math.floor(effectiveRunLog.requiredCorePapers)
-            : 0;
-        if (requiredCoreRaw > 0) {
-            effectiveRunLog.requiredCorePapers = Math.max(1, requiredCoreRaw);
-        }
-        else {
-            effectiveRunLog.requiredCorePapers = Math.max(1, Math.min(topicState.preferences.maxPapers, DEFAULT_STRICT_MIN_CORE_FLOOR));
-        }
-        if (typeof effectiveRunLog.requiredFullTextCoveragePct !== "number" ||
-            !Number.isFinite(effectiveRunLog.requiredFullTextCoveragePct) ||
-            effectiveRunLog.requiredFullTextCoveragePct < 80) {
-            effectiveRunLog.requiredFullTextCoveragePct = 80;
-        }
-    }
-    let effectiveKnowledgeState = args.knowledgeState || effectiveRunLog
-        ? {
-            ...(args.knowledgeState ?? {}),
-            ...(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 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) {
-            const knownIds = new Set(Object.keys(topicState.pushedPapers));
-            for (const paper of effectivePapers)
-                knownIds.add(derivePaperId(paper));
-            for (const paper of existingCorePapers) {
-                knownIds.add(derivePaperId({ id: paper.id, title: paper.title, url: paper.url }));
-            }
-            const fallback = await strictCoreFallbackSeed({
-                topic: topicState.topic,
-                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)));
-                let fallbackPapers = fallback.papers.filter((paper) => !existingIds.has(derivePaperId(paper)));
-                const needed = Math.max(0, requiredCoreFloor - strictSignalCount);
-                if (needed > 0) {
-                    if (fallbackPapers.length === 0)
-                        fallbackPapers = fallback.papers;
-                    fallbackPapers = fallbackPapers.slice(0, needed);
-                }
-                const fallbackIds = new Set(fallbackPapers.map((paper) => derivePaperId(paper)));
-                const fallbackCore = fallback.corePapers.filter((paper) => fallbackIds.has(derivePaperId({ id: paper.id, title: paper.title, url: paper.url })));
-                effectivePapers = dedupePaperRecords([...effectivePapers, ...fallbackPapers]);
-                const mergedRunLog = {
-                    ...(effectiveRunLog ?? { runProfile: "strict" }),
-                    recallTierStats: fallback.recallTierStats,
-                    notes: [
-                        effectiveRunLog?.notes,
-                        fallback.notes,
-                        `strict_core_topup required=${requiredCoreFloor} before=${strictSignalCount} added=${fallbackPapers.length}`,
-                    ]
-                        .filter((item) => Boolean(item && item.trim().length > 0))
-                        .join(" || "),
-                };
-                effectiveRunLog = mergedRunLog;
-                effectiveKnowledgeState = {
-                    ...(effectiveKnowledgeState ?? {}),
-                    corePapers: dedupeKnowledgePapers([...(effectiveKnowledgeState?.corePapers ?? []), ...fallbackCore]),
-                    explorationTrace: [
-                        ...(effectiveKnowledgeState?.explorationTrace ?? []),
-                        ...fallback.explorationTrace,
-                    ],
-                    runLog: mergedRunLog,
-                };
-            }
-        }
-    }
-    if (incomingRunProfile === "strict") {
-        const strictCoreFromState = effectiveKnowledgeState?.corePapers ?? [];
-        const strictCoreSeed = strictCoreFromState.length > 0
-            ? strictCoreFromState
-            : effectivePapers.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 } : {}),
-                ...(paper.reason ? { reason: paper.reason } : {}),
-                fullTextRead: false,
-                readStatus: "metadata",
-                unreadReason: "Full text not fetched yet; pending strict full-text bootstrap.",
-            }));
-        if (strictCoreSeed.length > 0) {
-            const strictAttemptLimit = Math.max(1, Math.min(MAX_STRICT_FULLTEXT_ATTEMPTS, effectiveRunLog?.requiredCorePapers ?? strictCoreSeed.length));
-            const backfilled = await backfillStrictCoreFullText({
-                corePapers: strictCoreSeed,
-                maxAttempts: strictAttemptLimit,
-            });
-            const strictRunLog = {
-                ...(effectiveRunLog ?? { runProfile: "strict" }),
-                fullTextAttempted: backfilled.attempted,
-                fullTextCompleted: backfilled.completed,
-                notes: [
-                    effectiveRunLog?.notes,
-                    `strict_fulltext_bootstrap attempted=${backfilled.attempted} completed=${backfilled.completed}`,
-                    ...(backfilled.failures.length > 0
-                        ? [`strict_fulltext_failures=${backfilled.failures.slice(0, 8).join(" | ")}`]
-                        : []),
-                ]
-                    .filter((item) => Boolean(item && item.trim().length > 0))
-                    .join(" || "),
-            };
-            effectiveRunLog = strictRunLog;
-            effectiveKnowledgeState = {
-                ...(effectiveKnowledgeState ?? {}),
-                corePapers: backfilled.corePapers,
-                runLog: strictRunLog,
-            };
-        }
-    }
-    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) +
-        (effectiveKnowledgeState?.knowledgeChanges?.length ?? 0) +
-        (effectiveKnowledgeState?.knowledgeUpdates?.length ?? 0) +
-        (effectiveKnowledgeState?.hypotheses?.length ?? 0) +
-        (effectiveKnowledgeState?.explorationTrace?.length ?? 0);
-    let normalizedStatus = statusRaw.length > 0 ? statusRaw : undefined;
-    const coercedFromEmptyWithArtifacts = normalizedStatus === "empty" && researchArtifactsCount > 0;
-    if (coercedFromEmptyWithArtifacts) {
-        normalizedStatus = "degraded_quality";
-    }
-    const hasRunError = Boolean(effectiveKnowledgeState?.runLog?.error && normalizeText(effectiveKnowledgeState.runLog.error).length > 0);
-    const requiresArtifacts = normalizedStatus === "ok" || normalizedStatus === "fallback_representative" || normalizedStatus === "degraded_quality";
-    if (requiresArtifacts && researchArtifactsCount === 0 && !hasRunError) {
-        throw new Error("record payload has no research artifacts. Use status=empty for no-result runs, or include run_log.error for failed runs.");
-    }
     let recordedPapers = 0;
-    for (const rawPaper of effectivePapers) {
+    for (const rawPaper of args.papers) {
         const id = derivePaperId(rawPaper);
         const existing = topicState.pushedPapers[id];
         if (existing) {
@@ -1716,12 +538,7 @@ export async function recordIncrementalPush(args) {
     }
     topicState.totalRuns += 1;
     topicState.lastRunAtMs = now;
-    topicState.lastStatus = normalizedStatus ?? (recordedPapers > 0 ? "ok" : "empty");
-    const effectiveNote = coercedFromEmptyWithArtifacts
-        ? [args.note?.trim(), "status coerced: empty -> degraded_quality because research artifacts were present"]
-            .filter((item) => Boolean(item && item.length > 0))
-            .join(" | ")
-        : args.note;
+    topicState.lastStatus = args.status?.trim() || (recordedPapers > 0 ? "ok" : "empty");
     const knowledgeCommitted = await commitKnowledgeRun({
         projectId: args.projectId ?? topicState.lastProjectId,
         scope: topicState.scope,
@@ -1729,9 +546,9 @@ export async function recordIncrementalPush(args) {
         topicKey: topicState.topicKey,
         status: topicState.lastStatus,
         runId: args.runId,
-        note: effectiveNote,
-        papers: effectivePapers,
-        knowledgeState: effectiveKnowledgeState,
+        note: args.note,
+        papers: args.papers,
+        knowledgeState: args.knowledgeState,
     });
     topicState.lastStatus = knowledgeCommitted.summary.lastStatus ?? topicState.lastStatus;
     topicState.lastProjectId = knowledgeCommitted.projectId;
@@ -1743,20 +560,18 @@ export async function recordIncrementalPush(args) {
         topicKey: topicState.topicKey,
         status: topicState.lastStatus,
         runId: knowledgeCommitted.runId,
-        run_id: knowledgeCommitted.runId,
-        run_profile: effectiveKnowledgeState?.runLog?.runProfile ?? null,
         projectId: knowledgeCommitted.projectId,
         streamKey: knowledgeCommitted.streamKey,
         preferences: topicState.preferences,
         recordedPapers,
-        papers: effectivePapers.map((paper) => ({
+        papers: args.papers.map((paper) => ({
             id: derivePaperId(paper),
             title: paper.title?.trim(),
             url: paper.url?.trim(),
             ...(typeof paper.score === "number" && Number.isFinite(paper.score) ? { score: paper.score } : {}),
             ...(paper.reason ? { reason: paper.reason.trim() } : {}),
         })),
-        note: effectiveNote,
+        note: args.note,
         knowledgeStateSummary: knowledgeCommitted.summary,
     });
     return {
@@ -1765,7 +580,6 @@ export async function recordIncrementalPush(args) {
         topicKey: topicState.topicKey,
         preferences: topicState.preferences,
         memoryHints: buildMemoryHints(memory),
-        runId: knowledgeCommitted.runId,
         recordedPapers,
         totalKnownPapers: Object.keys(topicState.pushedPapers).length,
         pushedAtMs: now,
@@ -1861,11 +675,6 @@ export async function getIncrementalStateStatus(args) {
     const lastPushedAtMs = excludePaperIds.length
         ? topicState.pushedPapers[excludePaperIds[0]]?.lastPushedAtMs
         : undefined;
-    const knowledgeStateMissingReason = knowledgeSummaryResult === undefined
-        ? args.projectId || topicState.lastProjectId
-            ? "project_or_stream_not_found"
-            : "project_unbound"
-        : undefined;
     return {
         scope: topicState.scope,
         topic: topicState.topic,
@@ -1879,7 +688,6 @@ export async function getIncrementalStateStatus(args) {
         ...(topicState.lastStatus ? { lastStatus: topicState.lastStatus } : {}),
         recentPapers: recentPapersByRecency(topicState.pushedPapers, 10),
         ...(knowledgeSummaryResult ? { knowledgeStateSummary: knowledgeSummaryResult.summary } : {}),
-        ...(knowledgeStateMissingReason ? { knowledgeStateMissingReason } : {}),
         recentHypotheses: knowledgeSummaryResult?.summary.recentHypotheses ?? [],
         recentChangeStats: knowledgeSummaryResult?.summary.recentChangeStats ?? [],
         lastExplorationTrace: knowledgeSummaryResult?.summary.lastExplorationTrace ?? [],