scientify 2.1.0 → 3.1.0

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

@@ -1,696 +0,0 @@
-import { createHash } from "node:crypto";
-import { mkdir, readFile, rename, writeFile, appendFile } from "node:fs/promises";
-import { existsSync } from "node:fs";
-import path from "node:path";
-import { commitKnowledgeRun, readKnowledgeSummary } from "../knowledge-state/store.js";
-const STATE_VERSION = 1;
-const DEFAULT_MAX_PAPERS = 5;
-const DEFAULT_SOURCES = ["openalex", "arxiv"];
-const MAX_MEMORY_NOTES = 30;
-const MAX_MEMORY_KEYS = 60;
-const TOP_HINT_LIMIT = 8;
-const FEEDBACK_SIGNAL_DELTA = {
-    read: 1,
-    skip: -1,
-    star: 2,
-};
-function getStateDir() {
-    const home = process.env.HOME || process.env.USERPROFILE || process.cwd();
-    return path.join(home, ".openclaw", "workspace", "scientify");
-}
-function getStatePath() {
-    return path.join(getStateDir(), "literature-state.json");
-}
-function getPushLogPath() {
-    return path.join(getStateDir(), "literature-push-log.jsonl");
-}
-function normalizeText(raw) {
-    return raw.trim().replace(/\s+/g, " ");
-}
-function normalizeTopic(raw) {
-    return normalizeText(raw).toLowerCase();
-}
-function sanitizeScopePart(raw) {
-    const normalized = normalizeText(raw).toLowerCase();
-    const cleaned = normalized
-        .replace(/[^a-z0-9_-]+/g, "-")
-        .replace(/-+/g, "-")
-        .replace(/^-|-$/g, "");
-    return cleaned || "unknown";
-}
-function normalizeScope(raw) {
-    const trimmed = normalizeText(raw).toLowerCase();
-    if (trimmed.length === 0)
-        return "global";
-    const split = trimmed.split(":");
-    if (split.length === 1) {
-        return sanitizeScopePart(split[0]);
-    }
-    const channel = sanitizeScopePart(split[0]);
-    const target = sanitizeScopePart(split.slice(1).join(":"));
-    return `${channel}:${target}`;
-}
-function topicKey(scope, topic) {
-    const hash = createHash("sha1")
-        .update(`${normalizeScope(scope)}\n${normalizeTopic(topic)}`)
-        .digest("hex");
-    return hash.slice(0, 20);
-}
-function dedupeSources(raw) {
-    if (!raw || raw.length === 0)
-        return [...DEFAULT_SOURCES];
-    const seen = new Set();
-    for (const item of raw) {
-        const value = normalizeText(item).toLowerCase();
-        if (value.length === 0)
-            continue;
-        seen.add(value);
-    }
-    if (seen.size === 0)
-        return [...DEFAULT_SOURCES];
-    return [...seen];
-}
-function mergePreferences(base, incoming) {
-    const maxPapersRaw = incoming?.maxPapers ?? base?.maxPapers ?? DEFAULT_MAX_PAPERS;
-    const maxPapers = Number.isFinite(maxPapersRaw)
-        ? Math.min(20, Math.max(1, Math.floor(maxPapersRaw)))
-        : DEFAULT_MAX_PAPERS;
-    const recencyRaw = incoming?.recencyDays ?? base?.recencyDays;
-    const recencyDays = recencyRaw !== undefined && Number.isFinite(recencyRaw) && recencyRaw > 0
-        ? Math.min(3650, Math.floor(recencyRaw))
-        : undefined;
-    const sources = dedupeSources(incoming?.sources ?? base?.sources);
-    return {
-        maxPapers,
-        ...(recencyDays ? { recencyDays } : {}),
-        sources,
-    };
-}
-function defaultState() {
-    return {
-        version: STATE_VERSION,
-        updatedAtMs: Date.now(),
-        topics: {},
-    };
-}
-function defaultTopicMemoryState() {
-    return {
-        feedbackCounts: {
-            read: 0,
-            skip: 0,
-            star: 0,
-        },
-        keywordScores: {},
-        sourceScores: {},
-        recentNotes: [],
-    };
-}
-async function ensureStateDir() {
-    await mkdir(getStateDir(), { recursive: true });
-}
-async function loadState() {
-    const file = getStatePath();
-    if (!existsSync(file))
-        return defaultState();
-    try {
-        const raw = await readFile(file, "utf-8");
-        const parsed = JSON.parse(raw);
-        if (parsed.version !== STATE_VERSION || !parsed.topics || typeof parsed.topics !== "object") {
-            return defaultState();
-        }
-        return {
-            version: STATE_VERSION,
-            updatedAtMs: typeof parsed.updatedAtMs === "number" ? parsed.updatedAtMs : Date.now(),
-            topics: parsed.topics,
-        };
-    }
-    catch {
-        return defaultState();
-    }
-}
-async function saveState(state) {
-    await ensureStateDir();
-    state.updatedAtMs = Date.now();
-    const file = getStatePath();
-    const tmp = `${file}.tmp`;
-    await writeFile(tmp, JSON.stringify(state, null, 2), "utf-8");
-    await rename(tmp, file);
-}
-function normalizePaperId(raw) {
-    if (!raw)
-        return undefined;
-    const normalized = normalizeText(raw).toLowerCase();
-    if (!normalized)
-        return undefined;
-    return normalized;
-}
-function extractArxivId(text) {
-    const m = text.match(/\b(\d{4}\.\d{4,5}(?:v\d+)?)\b/i);
-    if (m?.[1])
-        return `arxiv:${m[1].toLowerCase()}`;
-    return undefined;
-}
-function extractDoi(text) {
-    const m = text.match(/\b(10\.\d{4,9}\/[-._;()/:a-z0-9]+)\b/i);
-    if (m?.[1])
-        return `doi:${m[1].toLowerCase()}`;
-    return undefined;
-}
-function derivePaperId(paper) {
-    const explicit = normalizePaperId(paper.id);
-    if (explicit)
-        return explicit;
-    const text = [paper.url, paper.title].filter((part) => Boolean(part)).join(" ");
-    const arxiv = extractArxivId(text);
-    if (arxiv)
-        return arxiv;
-    const doi = extractDoi(text);
-    if (doi)
-        return doi;
-    const fallback = normalizeText(`${paper.title ?? ""} ${paper.url ?? ""}`);
-    const digest = createHash("sha1").update(fallback || JSON.stringify(paper)).digest("hex");
-    return `hash:${digest.slice(0, 20)}`;
-}
-function sanitizeKeyword(raw) {
-    const normalized = normalizeText(raw).toLowerCase();
-    if (normalized.length < 2 || normalized.length > 48)
-        return undefined;
-    return normalized;
-}
-function tokenizeKeywords(raw) {
-    const tokens = raw.match(/[\p{L}\p{N}][\p{L}\p{N}_-]{1,47}/gu) ?? [];
-    const seen = new Set();
-    for (const token of tokens) {
-        const keyword = sanitizeKeyword(token);
-        if (!keyword)
-            continue;
-        seen.add(keyword);
-    }
-    return [...seen];
-}
-function normalizeSource(raw) {
-    if (!raw)
-        return undefined;
-    const value = raw.trim().toLowerCase();
-    if (!value)
-        return undefined;
-    const direct = value.replace(/^https?:\/\//, "").replace(/^www\./, "").split("/")[0];
-    const host = direct.length > 0 ? direct : value;
-    if (host.includes("arxiv"))
-        return "arxiv";
-    if (host.includes("openalex"))
-        return "openalex";
-    if (host.includes("doi.org"))
-        return "doi";
-    if (host.includes("semanticscholar"))
-        return "semanticscholar";
-    if (host.includes("nature"))
-        return "nature";
-    if (host.includes("ieeexplore"))
-        return "ieee";
-    if (host.includes("acm.org"))
-        return "acm";
-    if (host.includes("sciencedirect"))
-        return "sciencedirect";
-    return host;
-}
-function sourceFromPaper(paper) {
-    const url = paper?.url?.trim();
-    if (!url)
-        return undefined;
-    try {
-        const host = new URL(url).host;
-        return normalizeSource(host);
-    }
-    catch {
-        return normalizeSource(url);
-    }
-}
-function updateScoreMap(map, key, delta) {
-    const current = map[key] ?? 0;
-    const next = Math.max(-20, Math.min(20, current + delta));
-    if (Math.abs(next) < 0.01) {
-        delete map[key];
-        return;
-    }
-    map[key] = Number(next.toFixed(2));
-}
-function limitScoreMap(map) {
-    const items = Object.entries(map)
-        .filter(([, value]) => Number.isFinite(value) && value !== 0)
-        .sort((a, b) => Math.abs(b[1]) - Math.abs(a[1]))
-        .slice(0, MAX_MEMORY_KEYS);
-    const trimmed = {};
-    for (const [key, value] of items) {
-        trimmed[key] = value;
-    }
-    return trimmed;
-}
-function ensureTopicMemoryState(topicState) {
-    const memory = topicState.memory;
-    if (!memory || typeof memory !== "object") {
-        topicState.memory = defaultTopicMemoryState();
-        return topicState.memory;
-    }
-    if (!memory.feedbackCounts || typeof memory.feedbackCounts !== "object") {
-        memory.feedbackCounts = { read: 0, skip: 0, star: 0 };
-    }
-    for (const key of ["read", "skip", "star"]) {
-        const raw = memory.feedbackCounts[key];
-        memory.feedbackCounts[key] = Number.isFinite(raw) ? Math.max(0, Math.floor(raw)) : 0;
-    }
-    if (!memory.keywordScores || typeof memory.keywordScores !== "object") {
-        memory.keywordScores = {};
-    }
-    else {
-        memory.keywordScores = limitScoreMap(memory.keywordScores);
-    }
-    if (!memory.sourceScores || typeof memory.sourceScores !== "object") {
-        memory.sourceScores = {};
-    }
-    else {
-        memory.sourceScores = limitScoreMap(memory.sourceScores);
-    }
-    if (!Array.isArray(memory.recentNotes)) {
-        memory.recentNotes = [];
-    }
-    else {
-        memory.recentNotes = memory.recentNotes
-            .filter((item) => item &&
-            typeof item === "object" &&
-            Number.isFinite(item.ts) &&
-            typeof item.signal === "string" &&
-            typeof item.text === "string")
-            .slice(-MAX_MEMORY_NOTES)
-            .map((item) => ({
-            ts: Math.floor(item.ts),
-            signal: item.signal,
-            text: normalizeText(item.text),
-        }));
-    }
-    if (!Number.isFinite(memory.lastFeedbackAtMs)) {
-        delete memory.lastFeedbackAtMs;
-    }
-    return memory;
-}
-function topKeysByScore(map, polarity, limit) {
-    const threshold = 0.1;
-    const entries = Object.entries(map).filter(([, score]) => polarity === "positive" ? score > threshold : score < -threshold);
-    entries.sort((a, b) => (polarity === "positive" ? b[1] - a[1] : a[1] - b[1]));
-    return entries.slice(0, limit).map(([key]) => key);
-}
-function buildMemoryHints(memory) {
-    return {
-        preferredKeywords: topKeysByScore(memory.keywordScores, "positive", TOP_HINT_LIMIT),
-        avoidedKeywords: topKeysByScore(memory.keywordScores, "negative", TOP_HINT_LIMIT),
-        preferredSources: topKeysByScore(memory.sourceScores, "positive", 4),
-        avoidedSources: topKeysByScore(memory.sourceScores, "negative", 4),
-        feedbackCounts: {
-            read: memory.feedbackCounts.read,
-            skip: memory.feedbackCounts.skip,
-            star: memory.feedbackCounts.star,
-        },
-        ...(memory.lastFeedbackAtMs ? { lastFeedbackAtMs: memory.lastFeedbackAtMs } : {}),
-    };
-}
-function getOrCreateTopicState(root, scope, topic, incomingPrefs) {
-    const normalizedScope = normalizeScope(scope);
-    const normalizedTopicDisplay = normalizeText(topic);
-    const key = topicKey(normalizedScope, normalizedTopicDisplay);
-    const expectedNormalizedTopic = normalizeTopic(normalizedTopicDisplay);
-    let existing = root.topics[key];
-    if (!existing) {
-        for (const [legacyKey, candidate] of Object.entries(root.topics)) {
-            if (!candidate || typeof candidate !== "object")
-                continue;
-            if (normalizeScope(candidate.scope) !== normalizedScope)
-                continue;
-            if (normalizeTopic(candidate.topic) !== expectedNormalizedTopic)
-                continue;
-            existing = candidate;
-            if (legacyKey !== key) {
-                delete root.topics[legacyKey];
-                root.topics[key] = candidate;
-            }
-            break;
-        }
-    }
-    if (existing) {
-        existing.scope = normalizedScope;
-        existing.topic = normalizedTopicDisplay;
-        existing.topicKey = key;
-        ensureTopicMemoryState(existing);
-        if (!existing.pushedPapers || typeof existing.pushedPapers !== "object") {
-            existing.pushedPapers = {};
-        }
-        if (!Number.isFinite(existing.totalRuns)) {
-            existing.totalRuns = 0;
-        }
-        existing.preferences = mergePreferences(existing.preferences, incomingPrefs);
-        // Merge duplicate legacy buckets produced by old scope normalization rules.
-        for (const [otherKey, other] of Object.entries(root.topics)) {
-            if (otherKey === key)
-                continue;
-            if (!other || typeof other !== "object")
-                continue;
-            if (normalizeScope(other.scope) !== normalizedScope)
-                continue;
-            if (normalizeTopic(other.topic) !== expectedNormalizedTopic)
-                continue;
-            ensureTopicMemoryState(other);
-            existing.preferences = mergePreferences(existing.preferences, other.preferences);
-            const existingMemory = ensureTopicMemoryState(existing);
-            const otherMemory = ensureTopicMemoryState(other);
-            existingMemory.feedbackCounts.read += otherMemory.feedbackCounts.read;
-            existingMemory.feedbackCounts.skip += otherMemory.feedbackCounts.skip;
-            existingMemory.feedbackCounts.star += otherMemory.feedbackCounts.star;
-            for (const [k, v] of Object.entries(otherMemory.keywordScores)) {
-                if (!Number.isFinite(v))
-                    continue;
-                updateScoreMap(existingMemory.keywordScores, k, v);
-            }
-            for (const [k, v] of Object.entries(otherMemory.sourceScores)) {
-                if (!Number.isFinite(v))
-                    continue;
-                updateScoreMap(existingMemory.sourceScores, k, v);
-            }
-            existingMemory.keywordScores = limitScoreMap(existingMemory.keywordScores);
-            existingMemory.sourceScores = limitScoreMap(existingMemory.sourceScores);
-            const mergedNotes = [...existingMemory.recentNotes, ...otherMemory.recentNotes]
-                .filter((item) => Number.isFinite(item.ts) && item.text.length > 0)
-                .sort((a, b) => a.ts - b.ts)
-                .slice(-MAX_MEMORY_NOTES);
-            existingMemory.recentNotes = mergedNotes;
-            const existingFb = existingMemory.lastFeedbackAtMs ?? 0;
-            const otherFb = otherMemory.lastFeedbackAtMs ?? 0;
-            if (otherFb > existingFb) {
-                existingMemory.lastFeedbackAtMs = otherFb;
-            }
-            for (const [paperId, paper] of Object.entries(other.pushedPapers ?? {})) {
-                const current = existing.pushedPapers[paperId];
-                if (!current) {
-                    existing.pushedPapers[paperId] = { ...paper };
-                    continue;
-                }
-                current.firstPushedAtMs = Math.min(current.firstPushedAtMs, paper.firstPushedAtMs);
-                const paperPushCount = Number.isFinite(paper.pushCount) ? Math.max(0, Math.floor(paper.pushCount)) : 0;
-                current.pushCount += paperPushCount;
-                if (paper.lastPushedAtMs > current.lastPushedAtMs) {
-                    current.lastPushedAtMs = paper.lastPushedAtMs;
-                    if (paper.title)
-                        current.title = paper.title;
-                    if (paper.url)
-                        current.url = paper.url;
-                    if (typeof paper.lastScore === "number" && Number.isFinite(paper.lastScore)) {
-                        current.lastScore = paper.lastScore;
-                    }
-                    if (paper.lastReason)
-                        current.lastReason = paper.lastReason;
-                }
-                else {
-                    if (!current.title && paper.title)
-                        current.title = paper.title;
-                    if (!current.url && paper.url)
-                        current.url = paper.url;
-                    if (current.lastScore === undefined && typeof paper.lastScore === "number" && Number.isFinite(paper.lastScore)) {
-                        current.lastScore = paper.lastScore;
-                    }
-                    if (!current.lastReason && paper.lastReason)
-                        current.lastReason = paper.lastReason;
-                }
-            }
-            const existingRuns = Number.isFinite(existing.totalRuns) ? Math.max(0, Math.floor(existing.totalRuns)) : 0;
-            const otherRuns = Number.isFinite(other.totalRuns) ? Math.max(0, Math.floor(other.totalRuns)) : 0;
-            existing.totalRuns = existingRuns + otherRuns;
-            const existingLastRun = existing.lastRunAtMs ?? 0;
-            const otherLastRun = other.lastRunAtMs ?? 0;
-            if (otherLastRun > existingLastRun) {
-                existing.lastRunAtMs = other.lastRunAtMs;
-                existing.lastStatus = other.lastStatus;
-                if (other.lastProjectId) {
-                    existing.lastProjectId = other.lastProjectId;
-                }
-            }
-            else if (!existing.lastStatus && other.lastStatus) {
-                existing.lastStatus = other.lastStatus;
-            }
-            delete root.topics[otherKey];
-        }
-        return existing;
-    }
-    const created = {
-        scope: normalizedScope,
-        topic: normalizedTopicDisplay,
-        topicKey: key,
-        preferences: mergePreferences(undefined, incomingPrefs),
-        memory: defaultTopicMemoryState(),
-        pushedPapers: {},
-        totalRuns: 0,
-    };
-    root.topics[key] = created;
-    return created;
-}
-function sortPaperIdsByRecency(papers) {
-    return Object.values(papers)
-        .sort((a, b) => b.lastPushedAtMs - a.lastPushedAtMs)
-        .map((item) => item.id);
-}
-function recentPapersByRecency(papers, limit) {
-    const normalizedLimit = Math.max(1, Math.min(50, Math.floor(limit)));
-    return Object.values(papers)
-        .sort((a, b) => b.lastPushedAtMs - a.lastPushedAtMs)
-        .slice(0, normalizedLimit)
-        .map((item) => ({
-        id: item.id,
-        ...(item.title ? { title: item.title } : {}),
-        ...(item.url ? { url: item.url } : {}),
-        ...(typeof item.lastScore === "number" && Number.isFinite(item.lastScore)
-            ? { lastScore: item.lastScore }
-            : {}),
-        ...(item.lastReason ? { lastReason: item.lastReason } : {}),
-        firstPushedAtMs: item.firstPushedAtMs,
-        lastPushedAtMs: item.lastPushedAtMs,
-        pushCount: item.pushCount,
-    }));
-}
-async function appendPushLog(entry) {
-    await ensureStateDir();
-    await appendFile(getPushLogPath(), `${JSON.stringify(entry)}\n`, "utf-8");
-}
-export async function prepareIncrementalState(args) {
-    const root = await loadState();
-    const topicState = getOrCreateTopicState(root, args.scope, args.topic, args.preferences);
-    const memory = ensureTopicMemoryState(topicState);
-    await saveState(root);
-    const excludePaperIds = sortPaperIdsByRecency(topicState.pushedPapers);
-    const lastPushedAtMs = excludePaperIds.length
-        ? topicState.pushedPapers[excludePaperIds[0]]?.lastPushedAtMs
-        : undefined;
-    return {
-        scope: topicState.scope,
-        topic: topicState.topic,
-        topicKey: topicState.topicKey,
-        preferences: topicState.preferences,
-        memoryHints: buildMemoryHints(memory),
-        excludePaperIds,
-        knownPaperCount: excludePaperIds.length,
-        ...(lastPushedAtMs ? { lastPushedAtMs } : {}),
-    };
-}
-export async function recordIncrementalPush(args) {
-    const root = await loadState();
-    const topicState = getOrCreateTopicState(root, args.scope, args.topic, args.preferences);
-    const memory = ensureTopicMemoryState(topicState);
-    const now = Date.now();
-    let recordedPapers = 0;
-    for (const rawPaper of args.papers) {
-        const id = derivePaperId(rawPaper);
-        const existing = topicState.pushedPapers[id];
-        if (existing) {
-            existing.lastPushedAtMs = now;
-            existing.pushCount += 1;
-            if (rawPaper.title)
-                existing.title = rawPaper.title.trim();
-            if (rawPaper.url)
-                existing.url = rawPaper.url.trim();
-            if (typeof rawPaper.score === "number" && Number.isFinite(rawPaper.score)) {
-                existing.lastScore = rawPaper.score;
-            }
-            if (rawPaper.reason) {
-                existing.lastReason = rawPaper.reason.trim();
-            }
-        }
-        else {
-            topicState.pushedPapers[id] = {
-                id,
-                title: rawPaper.title?.trim(),
-                url: rawPaper.url?.trim(),
-                ...(typeof rawPaper.score === "number" && Number.isFinite(rawPaper.score)
-                    ? { lastScore: rawPaper.score }
-                    : {}),
-                ...(rawPaper.reason ? { lastReason: rawPaper.reason.trim() } : {}),
-                firstPushedAtMs: now,
-                lastPushedAtMs: now,
-                pushCount: 1,
-            };
-        }
-        recordedPapers += 1;
-    }
-    topicState.totalRuns += 1;
-    topicState.lastRunAtMs = now;
-    topicState.lastStatus = args.status?.trim() || (recordedPapers > 0 ? "ok" : "empty");
-    const knowledgeCommitted = await commitKnowledgeRun({
-        projectId: args.projectId ?? topicState.lastProjectId,
-        scope: topicState.scope,
-        topic: topicState.topic,
-        topicKey: topicState.topicKey,
-        status: topicState.lastStatus,
-        runId: args.runId,
-        note: args.note,
-        papers: args.papers,
-        knowledgeState: args.knowledgeState,
-    });
-    topicState.lastStatus = knowledgeCommitted.summary.lastStatus ?? topicState.lastStatus;
-    topicState.lastProjectId = knowledgeCommitted.projectId;
-    await saveState(root);
-    await appendPushLog({
-        ts: now,
-        scope: topicState.scope,
-        topic: topicState.topic,
-        topicKey: topicState.topicKey,
-        status: topicState.lastStatus,
-        runId: knowledgeCommitted.runId,
-        projectId: knowledgeCommitted.projectId,
-        streamKey: knowledgeCommitted.streamKey,
-        preferences: topicState.preferences,
-        recordedPapers,
-        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: args.note,
-        knowledgeStateSummary: knowledgeCommitted.summary,
-    });
-    return {
-        scope: topicState.scope,
-        topic: topicState.topic,
-        topicKey: topicState.topicKey,
-        preferences: topicState.preferences,
-        memoryHints: buildMemoryHints(memory),
-        recordedPapers,
-        totalKnownPapers: Object.keys(topicState.pushedPapers).length,
-        pushedAtMs: now,
-        projectId: knowledgeCommitted.projectId,
-        streamKey: knowledgeCommitted.streamKey,
-        knowledgeStateSummary: knowledgeCommitted.summary,
-    };
-}
-export async function recordUserFeedback(args) {
-    const root = await loadState();
-    const topicState = getOrCreateTopicState(root, args.scope, args.topic, args.preferences);
-    const memory = ensureTopicMemoryState(topicState);
-    const now = Date.now();
-    const signal = args.feedback.signal;
-    const delta = FEEDBACK_SIGNAL_DELTA[signal];
-    memory.feedbackCounts[signal] += 1;
-    memory.lastFeedbackAtMs = now;
-    const keywords = new Set();
-    for (const tag of args.feedback.tags ?? []) {
-        const normalized = sanitizeKeyword(tag);
-        if (normalized)
-            keywords.add(normalized);
-    }
-    if (args.feedback.note) {
-        for (const token of tokenizeKeywords(args.feedback.note)) {
-            keywords.add(token);
-        }
-    }
-    if (args.feedback.paper?.title) {
-        for (const token of tokenizeKeywords(args.feedback.paper.title)) {
-            keywords.add(token);
-        }
-    }
-    for (const keyword of keywords) {
-        updateScoreMap(memory.keywordScores, keyword, delta);
-    }
-    memory.keywordScores = limitScoreMap(memory.keywordScores);
-    const source = normalizeSource(args.feedback.source) ?? sourceFromPaper(args.feedback.paper);
-    if (source) {
-        updateScoreMap(memory.sourceScores, source, delta);
-        memory.sourceScores = limitScoreMap(memory.sourceScores);
-    }
-    const noteText = normalizeText(args.feedback.note ?? "");
-    if (noteText.length > 0) {
-        memory.recentNotes.push({
-            ts: now,
-            signal,
-            text: noteText,
-        });
-        if (memory.recentNotes.length > MAX_MEMORY_NOTES) {
-            memory.recentNotes = memory.recentNotes.slice(-MAX_MEMORY_NOTES);
-        }
-    }
-    await saveState(root);
-    await appendPushLog({
-        ts: now,
-        event: "feedback",
-        scope: topicState.scope,
-        topic: topicState.topic,
-        topicKey: topicState.topicKey,
-        signal,
-        source: source ?? null,
-        tags: [...keywords],
-        note: noteText || undefined,
-        runId: args.feedback.runId,
-        memoryHints: buildMemoryHints(memory),
-    });
-    return {
-        scope: topicState.scope,
-        topic: topicState.topic,
-        topicKey: topicState.topicKey,
-        signal,
-        preferences: topicState.preferences,
-        memoryHints: buildMemoryHints(memory),
-        updatedAtMs: now,
-    };
-}
-export async function getIncrementalStateStatus(args) {
-    const root = await loadState();
-    const topicState = getOrCreateTopicState(root, args.scope, args.topic);
-    const memory = ensureTopicMemoryState(topicState);
-    const knowledgeSummaryResult = await readKnowledgeSummary({
-        scope: topicState.scope,
-        topic: topicState.topic,
-        topicKey: topicState.topicKey,
-        projectId: args.projectId ?? topicState.lastProjectId,
-    });
-    if (knowledgeSummaryResult?.projectId) {
-        topicState.lastProjectId = knowledgeSummaryResult.projectId;
-    }
-    await saveState(root);
-    const excludePaperIds = sortPaperIdsByRecency(topicState.pushedPapers);
-    const lastPushedAtMs = excludePaperIds.length
-        ? topicState.pushedPapers[excludePaperIds[0]]?.lastPushedAtMs
-        : undefined;
-    return {
-        scope: topicState.scope,
-        topic: topicState.topic,
-        topicKey: topicState.topicKey,
-        preferences: topicState.preferences,
-        memoryHints: buildMemoryHints(memory),
-        excludePaperIds,
-        knownPaperCount: excludePaperIds.length,
-        ...(lastPushedAtMs ? { lastPushedAtMs } : {}),
-        totalRuns: topicState.totalRuns,
-        ...(topicState.lastStatus ? { lastStatus: topicState.lastStatus } : {}),
-        recentPapers: recentPapersByRecency(topicState.pushedPapers, 10),
-        ...(knowledgeSummaryResult ? { knowledgeStateSummary: knowledgeSummaryResult.summary } : {}),
-        recentHypotheses: knowledgeSummaryResult?.summary.recentHypotheses ?? [],
-        recentChangeStats: knowledgeSummaryResult?.summary.recentChangeStats ?? [],
-        lastExplorationTrace: knowledgeSummaryResult?.summary.lastExplorationTrace ?? [],
-    };
-}
-//# sourceMappingURL=subscription-state.js.map