scientify 1.12.0 → 1.12.2

package/dist/src/knowledge-state/store.js

@@ -2,18 +2,36 @@ import { createHash } from "node:crypto";
 import { existsSync } from "node:fs";
 import { appendFile, mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { dayKeyFromTimestamp, renderDailyChangesMarkdown, renderExplorationLogMarkdown, renderHypothesisMarkdown, renderIngestLogMarkdown, renderKnowledgeIndexMarkdown, renderPaperNoteHeaderMarkdown, renderPaperNoteRunMarkdown, renderTopicUpdateMarkdown, slugifyTopic, } from "./render.js";
+import { dayKeyFromTimestamp, renderDailyChangesMarkdown, renderExplorationLogMarkdown, renderHypothesisMarkdown, renderIngestLogMarkdown, renderKnowledgeIndexMarkdown, renderPaperNoteHeaderMarkdown, renderPaperNoteRunMarkdown, renderReflectionLogMarkdown, renderTopicUpdateMarkdown, slugifyTopic, } from "./render.js";
 import { resolveProjectContext } from "./project.js";
 const STATE_VERSION = 1;
 const MAX_RECENT_RUN_IDS = 200;
 const MAX_RECENT_HYPOTHESES = 50;
 const MAX_RECENT_CHANGE_STATS = 30;
 const MAX_LAST_TRACE = 20;
+const MAX_LAST_REFLECTION_TASKS = 20;
 const MAX_RECENT_PAPERS = 50;
 const MAX_PAPER_NOTES = 800;
+const MAX_HYPOTHESIS_REJECTION_REASONS = 24;
 const MIN_CORE_FULLTEXT_COVERAGE = 0.8;
 const MIN_EVIDENCE_BINDING_RATE = 0.9;
 const MAX_CITATION_ERROR_RATE = 0.02;
+const MIN_FULLTEXT_PROFILE_COMPLETENESS = 0.55;
+const MIN_HYPOTHESIS_EVIDENCE = 2;
+const MIN_HYPOTHESIS_DEPENDENCY_STEPS = 2;
+const MIN_HYPOTHESIS_STATEMENT_CHARS = 48;
+const PLACEHOLDER_TEXT_RE = /^(?:n\/a|na|none|not provided|not available|unknown|tbd|todo|null|nil|未提供|暂无|未知|无)$/iu;
+function defaultRunProfile() {
+    return "strict";
+}
+function defaultTriggerState(nowMs = Date.now()) {
+    return {
+        consecutiveNewReviseDays: 0,
+        bridgeCount7d: 0,
+        unreadCoreBacklog: 0,
+        lastUpdatedAtMs: nowMs,
+    };
+}
 function defaultQualityGateState() {
     return {
         passed: false,
@@ -23,9 +41,26 @@ function defaultQualityGateState() {
         reasons: ["quality gate not evaluated"],
     };
 }
+function defaultHypothesisGateState() {
+    return {
+        accepted: 0,
+        rejected: 0,
+        rejectionReasons: [],
+    };
+}
 function normalizeText(raw) {
     return raw.trim().replace(/\s+/g, " ");
 }
+function cleanOptionalText(raw) {
+    if (typeof raw !== "string")
+        return undefined;
+    const normalized = normalizeText(raw);
+    if (!normalized)
+        return undefined;
+    if (PLACEHOLDER_TEXT_RE.test(normalized))
+        return undefined;
+    return normalized;
+}
 function sanitizeId(raw) {
     return normalizeText(raw)
         .toLowerCase()
@@ -106,6 +141,9 @@ async function loadState(projectPath) {
                 topic: normalizeText(rawStream.topic ?? "topic"),
                 topicKey,
                 projectId: sanitizeId(rawStream.projectId ?? "auto-topic-global-000000") || "auto-topic-global-000000",
+                lastRunProfile: rawStream.lastRunProfile === "strict" || rawStream.lastRunProfile === "fast"
+                    ? rawStream.lastRunProfile
+                    : defaultRunProfile(),
                 totalRuns: typeof rawStream.totalRuns === "number" ? Math.max(0, Math.floor(rawStream.totalRuns)) : 0,
                 totalHypotheses: typeof rawStream.totalHypotheses === "number" ? Math.max(0, Math.floor(rawStream.totalHypotheses)) : 0,
                 knowledgeTopics: Array.isArray(rawStream.knowledgeTopics)
@@ -114,6 +152,26 @@ async function loadState(projectPath) {
                 paperNotes: Array.isArray(rawStream.paperNotes)
                     ? rawStream.paperNotes.filter((item) => typeof item === "string").map((item) => normalizeText(item))
                     : [],
+                triggerState: rawStream.triggerState && typeof rawStream.triggerState === "object" && !Array.isArray(rawStream.triggerState)
+                    ? {
+                        consecutiveNewReviseDays: typeof rawStream.triggerState.consecutiveNewReviseDays === "number" &&
+                            Number.isFinite(rawStream.triggerState.consecutiveNewReviseDays)
+                            ? Math.max(0, Math.floor(rawStream.triggerState.consecutiveNewReviseDays))
+                            : 0,
+                        bridgeCount7d: typeof rawStream.triggerState.bridgeCount7d === "number" &&
+                            Number.isFinite(rawStream.triggerState.bridgeCount7d)
+                            ? Math.max(0, Math.floor(rawStream.triggerState.bridgeCount7d))
+                            : 0,
+                        unreadCoreBacklog: typeof rawStream.triggerState.unreadCoreBacklog === "number" &&
+                            Number.isFinite(rawStream.triggerState.unreadCoreBacklog)
+                            ? Math.max(0, Math.floor(rawStream.triggerState.unreadCoreBacklog))
+                            : 0,
+                        lastUpdatedAtMs: typeof rawStream.triggerState.lastUpdatedAtMs === "number" &&
+                            Number.isFinite(rawStream.triggerState.lastUpdatedAtMs)
+                            ? Math.floor(rawStream.triggerState.lastUpdatedAtMs)
+                            : Date.now(),
+                    }
+                    : defaultTriggerState(),
                 recentFullTextReadCount: typeof rawStream.recentFullTextReadCount === "number"
                     ? Math.max(0, Math.floor(rawStream.recentFullTextReadCount))
                     : 0,
@@ -178,6 +236,39 @@ async function loadState(projectPath) {
                         .map(normalizeTrace)
                         .filter((item) => Boolean(item))
                     : [],
+                lastReflectionTasks: Array.isArray(rawStream.lastReflectionTasks)
+                    ? rawStream.lastReflectionTasks
+                        .filter((item) => !!item && typeof item === "object")
+                        .map((item) => ({
+                        id: sanitizeId(item.id ?? "task"),
+                        trigger: ["BRIDGE", "TREND", "CONTRADICTION", "UNREAD_CORE"].includes(item.trigger)
+                            ? item.trigger
+                            : "TREND",
+                        reason: normalizeText(item.reason ?? ""),
+                        query: normalizeText(item.query ?? ""),
+                        priority: ["high", "medium", "low"].includes(item.priority) ? item.priority : "medium",
+                        status: (item.status === "executed" ? "executed" : "planned"),
+                    }))
+                        .filter((item) => item.reason.length > 0 && item.query.length > 0)
+                    : [],
+                lastHypothesisGate: rawStream.lastHypothesisGate &&
+                    typeof rawStream.lastHypothesisGate === "object" &&
+                    !Array.isArray(rawStream.lastHypothesisGate)
+                    ? {
+                        accepted: typeof rawStream.lastHypothesisGate.accepted === "number"
+                            ? Math.max(0, Math.floor(rawStream.lastHypothesisGate.accepted))
+                            : 0,
+                        rejected: typeof rawStream.lastHypothesisGate.rejected === "number"
+                            ? Math.max(0, Math.floor(rawStream.lastHypothesisGate.rejected))
+                            : 0,
+                        rejectionReasons: Array.isArray(rawStream.lastHypothesisGate.rejectionReasons)
+                            ? rawStream.lastHypothesisGate.rejectionReasons
+                                .filter((item) => typeof item === "string")
+                                .map((item) => normalizeText(item))
+                                .filter((item) => item.length > 0)
+                            : [],
+                    }
+                    : defaultHypothesisGateState(),
             };
         }
         return {
@@ -208,8 +299,8 @@ function normalizeStringArray(raw) {
         return undefined;
     const values = raw
         .filter((item) => typeof item === "string")
-        .map((item) => normalizeText(item))
-        .filter((item) => item.length > 0);
+        .map((item) => cleanOptionalText(item))
+        .filter((item) => Boolean(item));
     return values.length > 0 ? values : undefined;
 }
 function normalizeEvidenceAnchors(raw) {
@@ -218,14 +309,14 @@ function normalizeEvidenceAnchors(raw) {
     const anchors = raw
         .filter((item) => !!item && typeof item === "object")
         .map((item) => {
-        const claim = normalizeText(item.claim ?? "");
+        const claim = cleanOptionalText(item.claim);
         if (!claim)
             return undefined;
         return {
-            ...(item.section ? { section: normalizeText(item.section) } : {}),
-            ...(item.locator ? { locator: normalizeText(item.locator) } : {}),
+            ...(cleanOptionalText(item.section) ? { section: cleanOptionalText(item.section) } : {}),
+            ...(cleanOptionalText(item.locator) ? { locator: cleanOptionalText(item.locator) } : {}),
             claim,
-            ...(item.quote ? { quote: normalizeText(item.quote) } : {}),
+            ...(cleanOptionalText(item.quote) ? { quote: cleanOptionalText(item.quote) } : {}),
         };
     })
         .filter((item) => Boolean(item));
@@ -243,7 +334,7 @@ function toPaperNoteSlug(paper) {
 }
 function normalizePaper(input) {
     const evidenceIds = Array.isArray(input.evidenceIds)
-        ? input.evidenceIds.map((id) => normalizeText(id)).filter((id) => id.length > 0)
+        ? input.evidenceIds.map((id) => cleanOptionalText(id)).filter((id) => Boolean(id))
         : undefined;
     const keyEvidenceSpans = normalizeStringArray(input.keyEvidenceSpans);
     const subdomains = normalizeStringArray(input.subdomains);
@@ -264,31 +355,33 @@ function normalizePaper(input) {
             : readStatus
                 ? false
                 : undefined;
-    const unreadReason = input.unreadReason ? normalizeText(input.unreadReason) : undefined;
+    const unreadReason = cleanOptionalText(input.unreadReason);
     return {
-        ...(input.id ? { id: normalizeText(input.id) } : {}),
-        ...(input.title ? { title: normalizeText(input.title) } : {}),
-        ...(input.url ? { url: normalizeText(input.url) } : {}),
-        ...(input.source ? { source: normalizeText(input.source) } : {}),
-        ...(input.publishedAt ? { publishedAt: normalizeText(input.publishedAt) } : {}),
+        ...(cleanOptionalText(input.id) ? { id: cleanOptionalText(input.id) } : {}),
+        ...(cleanOptionalText(input.title) ? { title: cleanOptionalText(input.title) } : {}),
+        ...(cleanOptionalText(input.url) ? { url: cleanOptionalText(input.url) } : {}),
+        ...(cleanOptionalText(input.source) ? { source: cleanOptionalText(input.source) } : {}),
+        ...(cleanOptionalText(input.publishedAt) ? { publishedAt: cleanOptionalText(input.publishedAt) } : {}),
         ...(typeof input.score === "number" && Number.isFinite(input.score)
             ? { score: Number(input.score.toFixed(2)) }
             : {}),
-        ...(input.reason ? { reason: normalizeText(input.reason) } : {}),
-        ...(input.summary ? { summary: normalizeText(input.summary) } : {}),
+        ...(cleanOptionalText(input.reason) ? { reason: cleanOptionalText(input.reason) } : {}),
+        ...(cleanOptionalText(input.summary) ? { summary: cleanOptionalText(input.summary) } : {}),
         ...(evidenceIds && evidenceIds.length > 0 ? { evidenceIds } : {}),
         ...(typeof fullTextRead === "boolean" ? { fullTextRead } : {}),
         ...(readStatus ? { readStatus } : {}),
-        ...(input.fullTextSource ? { fullTextSource: normalizeText(input.fullTextSource) } : {}),
-        ...(input.fullTextRef ? { fullTextRef: normalizeText(input.fullTextRef) } : {}),
+        ...(cleanOptionalText(input.fullTextSource) ? { fullTextSource: cleanOptionalText(input.fullTextSource) } : {}),
+        ...(cleanOptionalText(input.fullTextRef) ? { fullTextRef: cleanOptionalText(input.fullTextRef) } : {}),
         ...(unreadReason ? { unreadReason } : {}),
         ...(keyEvidenceSpans && keyEvidenceSpans.length > 0 ? { keyEvidenceSpans } : {}),
-        ...(input.domain ? { domain: normalizeText(input.domain) } : {}),
+        ...(cleanOptionalText(input.domain) ? { domain: cleanOptionalText(input.domain) } : {}),
         ...(subdomains ? { subdomains } : {}),
         ...(crossDomainLinks ? { crossDomainLinks } : {}),
-        ...(input.researchGoal ? { researchGoal: normalizeText(input.researchGoal) } : {}),
-        ...(input.approach ? { approach: normalizeText(input.approach) } : {}),
-        ...(input.methodologyDesign ? { methodologyDesign: normalizeText(input.methodologyDesign) } : {}),
+        ...(cleanOptionalText(input.researchGoal) ? { researchGoal: cleanOptionalText(input.researchGoal) } : {}),
+        ...(cleanOptionalText(input.approach) ? { approach: cleanOptionalText(input.approach) } : {}),
+        ...(cleanOptionalText(input.methodologyDesign)
+            ? { methodologyDesign: cleanOptionalText(input.methodologyDesign) }
+            : {}),
         ...(keyContributions ? { keyContributions } : {}),
         ...(practicalInsights ? { practicalInsights } : {}),
         ...(mustUnderstandPoints ? { mustUnderstandPoints } : {}),
@@ -401,6 +494,32 @@ function hasStructuredProfile(paper) {
         (paper.limitations && paper.limitations.length > 0) ||
         (paper.evidenceAnchors && paper.evidenceAnchors.length > 0));
 }
+function countStructuredProfileFields(paper) {
+    let count = 0;
+    if (paper.domain && paper.domain.trim())
+        count += 1;
+    if (paper.subdomains && paper.subdomains.length > 0)
+        count += 1;
+    if (paper.crossDomainLinks && paper.crossDomainLinks.length > 0)
+        count += 1;
+    if (paper.researchGoal && paper.researchGoal.trim())
+        count += 1;
+    if (paper.approach && paper.approach.trim())
+        count += 1;
+    if (paper.methodologyDesign && paper.methodologyDesign.trim())
+        count += 1;
+    if (paper.keyContributions && paper.keyContributions.length > 0)
+        count += 1;
+    if (paper.practicalInsights && paper.practicalInsights.length > 0)
+        count += 1;
+    if (paper.mustUnderstandPoints && paper.mustUnderstandPoints.length > 0)
+        count += 1;
+    if (paper.limitations && paper.limitations.length > 0)
+        count += 1;
+    if (paper.evidenceAnchors && paper.evidenceAnchors.length > 0)
+        count += 1;
+    return count;
+}
 function isFullTextRead(paper) {
     return paper.fullTextRead === true || paper.readStatus === "fulltext";
 }
@@ -447,6 +566,13 @@ function applyQualityGates(args) {
     const fullTextCoreCount = corePapers.filter((paper) => isFullTextRead(paper)).length;
     const fullTextCoverage = coreCount > 0 ? fullTextCoreCount / coreCount : 0;
     const fullTextCoveragePct = Number((fullTextCoverage * 100).toFixed(2));
+    const fullTextCorePapers = corePapers.filter((paper) => isFullTextRead(paper));
+    const structuredFieldTotal = 11;
+    const avgFullTextProfileCompleteness = fullTextCorePapers.length > 0
+        ? fullTextCorePapers.reduce((sum, paper) => sum + countStructuredProfileFields(paper) / structuredFieldTotal, 0) /
+            fullTextCorePapers.length
+        : 0;
+    const avgFullTextProfileCompletenessPct = Number((avgFullTextProfileCompleteness * 100).toFixed(2));
     const unreadCorePaperIds = dedupeText(corePapers
         .filter((paper) => !isFullTextRead(paper))
         .map((paper) => paper.id?.trim() || paper.url?.trim() || paper.title?.trim() || "unknown-paper")).slice(0, 50);
@@ -522,15 +648,43 @@ function applyQualityGates(args) {
         }
     }
     const reasons = [];
+    if (typeof args.requiredCorePapers === "number" &&
+        Number.isFinite(args.requiredCorePapers) &&
+        args.requiredCorePapers > 0 &&
+        coreCount < args.requiredCorePapers) {
+        reasons.push(`core_paper_count_below_required(${coreCount} < ${Math.floor(args.requiredCorePapers)})`);
+    }
     if (fullTextCoverage < MIN_CORE_FULLTEXT_COVERAGE) {
         reasons.push(`core_fulltext_coverage_below_threshold(${fullTextCoveragePct}% < ${Number((MIN_CORE_FULLTEXT_COVERAGE * 100).toFixed(0))}%)`);
     }
+    if (fullTextCorePapers.length > 0 && avgFullTextProfileCompleteness < MIN_FULLTEXT_PROFILE_COMPLETENESS) {
+        reasons.push(`fulltext_profile_completeness_below_threshold(${avgFullTextProfileCompletenessPct}% < ${Number((MIN_FULLTEXT_PROFILE_COMPLETENESS * 100).toFixed(0))}%)`);
+    }
+    if (typeof args.requiredFullTextCoveragePct === "number" &&
+        Number.isFinite(args.requiredFullTextCoveragePct) &&
+        args.requiredFullTextCoveragePct > 0 &&
+        fullTextCoveragePct < args.requiredFullTextCoveragePct) {
+        reasons.push(`core_fulltext_coverage_below_required(${fullTextCoveragePct}% < ${Number(args.requiredFullTextCoveragePct.toFixed(2))}%)`);
+    }
     if (evidenceBindingRate < MIN_EVIDENCE_BINDING_RATE) {
         reasons.push(`evidence_binding_rate_below_threshold(${evidenceBindingRatePct}% < ${Number((MIN_EVIDENCE_BINDING_RATE * 100).toFixed(0))}%)`);
     }
     if (citationErrorRate >= MAX_CITATION_ERROR_RATE) {
         reasons.push(`citation_error_rate_above_threshold(${citationErrorRatePct}% >= ${Number((MAX_CITATION_ERROR_RATE * 100).toFixed(0))}%)`);
     }
+    const bridgeChangeCount = args.knowledgeChanges.filter((item) => item.type === "BRIDGE").length;
+    const reviseCount = args.knowledgeChanges.filter((item) => item.type === "REVISE").length;
+    const confirmCount = args.knowledgeChanges.filter((item) => item.type === "CONFIRM").length;
+    const executedReflectionCount = args.reflectionTasks.filter((task) => task.status === "executed").length;
+    if (bridgeChangeCount > 0 && executedReflectionCount === 0) {
+        reasons.push(`reflection_missing_for_bridge(bridge_count=${bridgeChangeCount})`);
+    }
+    if (reviseCount > 0 && confirmCount > 0 && executedReflectionCount === 0) {
+        reasons.push(`reflection_missing_for_conflict(revise_count=${reviseCount},confirm_count=${confirmCount})`);
+    }
+    if (args.hypothesisGate.rejected > 0 && args.hypothesisGate.accepted === 0 && args.hypotheses.length > 0) {
+        reasons.push(`hypothesis_gate_rejected_all(${args.hypothesisGate.rejected})`);
+    }
     if (downgradedHighConfidenceCount > 0) {
         reasons.push(`high_confidence_downgraded(${downgradedHighConfidenceCount})`);
     }
@@ -642,10 +796,12 @@ function toSummary(stream) {
     return {
         projectId: stream.projectId,
         streamKey: stream.topicKey,
+        runProfile: stream.lastRunProfile,
         totalRuns: stream.totalRuns,
         totalHypotheses: stream.totalHypotheses,
         knowledgeTopicsCount: stream.knowledgeTopics.length,
         paperNotesCount: stream.paperNotes.length,
+        triggerState: stream.triggerState,
         recentFullTextReadCount: stream.recentFullTextReadCount,
         recentNotFullTextReadCount: stream.recentNotFullTextReadCount,
         qualityGate: stream.lastQualityGate,
@@ -656,6 +812,8 @@ function toSummary(stream) {
         recentHypotheses: stream.recentHypotheses,
         recentChangeStats: stream.recentChangeStats,
         lastExplorationTrace: stream.lastExplorationTrace,
+        lastReflectionTasks: stream.lastReflectionTasks,
+        hypothesisGate: stream.lastHypothesisGate,
     };
 }
 function countChangeStats(day, runId, changes) {
@@ -682,6 +840,277 @@ function countChangeStats(day, runId, changes) {
         bridgeCount,
     };
 }
+function tokenizeForQuery(raw) {
+    return normalizeText(raw)
+        .toLowerCase()
+        .replace(/[^a-z0-9\u4e00-\u9fff\s_-]+/g, " ")
+        .split(/\s+/)
+        .map((item) => item.trim())
+        .filter((item) => item.length >= 3);
+}
+function uniqueText(values) {
+    return [...new Set(values.map((item) => normalizeText(item)).filter((item) => item.length > 0))];
+}
+function buildReflectionQuery(topic, statement, fallbackHint) {
+    const topicTokens = tokenizeForQuery(topic).slice(0, 4);
+    const stmtTokens = tokenizeForQuery(statement).slice(0, 6);
+    const merged = uniqueText([...topicTokens, ...stmtTokens]);
+    if (merged.length === 0)
+        return `${topic} ${fallbackHint}`.trim();
+    return merged.join(" ");
+}
+function queryMatchesTrace(query, trace) {
+    const tokens = tokenizeForQuery(query).slice(0, 4);
+    if (tokens.length === 0)
+        return false;
+    return trace.some((step) => {
+        const hay = normalizeText(step.query).toLowerCase();
+        let hit = 0;
+        for (const token of tokens) {
+            if (hay.includes(token))
+                hit += 1;
+            if (hit >= Math.min(2, tokens.length))
+                return true;
+        }
+        return false;
+    });
+}
+function deriveReflectionTasks(args) {
+    const tasks = [];
+    const bridge = args.changes.filter((item) => item.type === "BRIDGE");
+    const revise = args.changes.filter((item) => item.type === "REVISE");
+    const confirm = args.changes.filter((item) => item.type === "CONFIRM");
+    const newly = args.changes.filter((item) => item.type === "NEW");
+    for (const [idx, change] of bridge.slice(0, 3).entries()) {
+        const query = buildReflectionQuery(args.topic, change.statement, "cross-domain mechanism");
+        tasks.push({
+            id: sanitizeId(`bridge-${idx + 1}-${query}`),
+            trigger: "BRIDGE",
+            reason: `Bridge signal requires cross-domain follow-up: ${change.statement}`,
+            query,
+            priority: "high",
+            status: queryMatchesTrace(query, args.trace) ? "executed" : "planned",
+        });
+    }
+    if (newly.length >= 3) {
+        const query = buildReflectionQuery(args.topic, newly.map((item) => item.statement).join(" "), "trend synthesis");
+        tasks.push({
+            id: sanitizeId(`trend-${query}`),
+            trigger: "TREND",
+            reason: `New findings accumulated (${newly.length}); run trend synthesis and gap scan.`,
+            query,
+            priority: "medium",
+            status: queryMatchesTrace(query, args.trace) ? "executed" : "planned",
+        });
+    }
+    if (revise.length > 0 && confirm.length > 0) {
+        const query = buildReflectionQuery(args.topic, `${revise[0]?.statement ?? ""} ${confirm[0]?.statement ?? ""}`, "contradiction resolution");
+        tasks.push({
+            id: sanitizeId(`contradiction-${query}`),
+            trigger: "CONTRADICTION",
+            reason: `Revise and confirm signals co-exist; verify contradiction boundaries.`,
+            query,
+            priority: "high",
+            status: queryMatchesTrace(query, args.trace) ? "executed" : "planned",
+        });
+    }
+    const unreadCore = args.corePapers.filter((paper) => !isFullTextRead(paper));
+    if (unreadCore.length > 0) {
+        const topId = unreadCore[0]?.id ?? unreadCore[0]?.title ?? "core-paper";
+        const query = buildReflectionQuery(args.topic, String(topId), "full text retrieval");
+        tasks.push({
+            id: sanitizeId(`unread-core-${query}`),
+            trigger: "UNREAD_CORE",
+            reason: `${unreadCore.length} core paper(s) were not fully read; prioritize retrieval and verification.`,
+            query,
+            priority: "medium",
+            status: queryMatchesTrace(query, args.trace) ? "executed" : "planned",
+        });
+    }
+    const dedup = new Map();
+    for (const task of tasks) {
+        const key = normalizeText(task.query).toLowerCase();
+        if (!key)
+            continue;
+        const existing = dedup.get(key);
+        if (!existing) {
+            dedup.set(key, task);
+            continue;
+        }
+        // Keep higher priority / executed status when duplicates collide.
+        const priorityRank = { high: 3, medium: 2, low: 1 };
+        const pick = (existing.status !== "executed" && task.status === "executed") ||
+            priorityRank[task.priority] > priorityRank[existing.priority]
+            ? task
+            : existing;
+        dedup.set(key, pick);
+    }
+    return [...dedup.values()].slice(0, MAX_LAST_REFLECTION_TASKS);
+}
+function sanitizeKnowledgeChanges(args) {
+    if (args.changes.length === 0) {
+        return {
+            changes: [],
+            droppedBridgeCount: 0,
+        };
+    }
+    const paperLookup = buildPaperLookup(args.allRunPapers);
+    const next = [];
+    let droppedBridgeCount = 0;
+    for (const change of args.changes) {
+        if (change.type !== "BRIDGE") {
+            next.push(change);
+            continue;
+        }
+        const evidenceIds = (change.evidenceIds ?? []).map((id) => normalizedCitationToken(id)).filter((id) => id.length > 0);
+        if (evidenceIds.length === 0) {
+            droppedBridgeCount += 1;
+            continue;
+        }
+        let hasResolvedEvidence = false;
+        let hasFullTextEvidence = false;
+        for (const evidenceId of evidenceIds) {
+            const paper = paperLookup.get(evidenceId);
+            if (!paper)
+                continue;
+            hasResolvedEvidence = true;
+            if (isFullTextRead(paper))
+                hasFullTextEvidence = true;
+        }
+        // Guard against speculative bridge signals with no grounded full-text evidence.
+        if (!hasResolvedEvidence || !hasFullTextEvidence) {
+            droppedBridgeCount += 1;
+            continue;
+        }
+        next.push(change);
+    }
+    return {
+        changes: next,
+        droppedBridgeCount,
+    };
+}
+function applyHypothesisGate(args) {
+    const acceptedHypotheses = [];
+    const rejectionReasonSet = new Set();
+    const paperLookup = buildPaperLookup(args.allRunPapers);
+    const changeCounts = {
+        NEW: args.knowledgeChanges.filter((item) => item.type === "NEW").length,
+        CONFIRM: args.knowledgeChanges.filter((item) => item.type === "CONFIRM").length,
+        REVISE: args.knowledgeChanges.filter((item) => item.type === "REVISE").length,
+        BRIDGE: args.knowledgeChanges.filter((item) => item.type === "BRIDGE").length,
+    };
+    for (const hypothesis of args.hypotheses) {
+        const reasons = [];
+        const statementLen = normalizeText(hypothesis.statement).length;
+        if (statementLen < MIN_HYPOTHESIS_STATEMENT_CHARS) {
+            reasons.push(`statement_too_short(${statementLen}<${MIN_HYPOTHESIS_STATEMENT_CHARS})`);
+        }
+        const evidenceIds = uniqueText((hypothesis.evidenceIds ?? []).map((id) => normalizedCitationToken(id)));
+        if (evidenceIds.length < MIN_HYPOTHESIS_EVIDENCE) {
+            reasons.push(`insufficient_evidence_ids(${evidenceIds.length}<${MIN_HYPOTHESIS_EVIDENCE})`);
+        }
+        let resolvedEvidence = 0;
+        let fullTextSupported = 0;
+        for (const evidenceId of evidenceIds) {
+            const paper = paperLookup.get(evidenceId);
+            if (!paper)
+                continue;
+            resolvedEvidence += 1;
+            if (isFullTextRead(paper))
+                fullTextSupported += 1;
+        }
+        if (resolvedEvidence < evidenceIds.length) {
+            reasons.push(`unresolved_evidence_ids(${evidenceIds.length - resolvedEvidence})`);
+        }
+        if (fullTextSupported === 0 && args.runProfile === "strict") {
+            reasons.push("no_fulltext_backed_evidence");
+        }
+        if (resolvedEvidence === 0) {
+            reasons.push("no_resolved_evidence");
+        }
+        const dependencyPathLength = hypothesis.dependencyPath?.length ?? 0;
+        if (dependencyPathLength < MIN_HYPOTHESIS_DEPENDENCY_STEPS) {
+            reasons.push(`dependency_path_too_short(${dependencyPathLength}<${MIN_HYPOTHESIS_DEPENDENCY_STEPS})`);
+        }
+        const hasScore = typeof hypothesis.novelty === "number" &&
+            typeof hypothesis.feasibility === "number" &&
+            typeof hypothesis.impact === "number";
+        if (!hasScore) {
+            reasons.push("missing_self_assessment_scores");
+        }
+        if (hypothesis.trigger === "BRIDGE" && changeCounts.BRIDGE === 0) {
+            reasons.push("trigger_bridge_without_bridge_change");
+        }
+        if (hypothesis.trigger === "TREND" && changeCounts.NEW < 2) {
+            reasons.push("trigger_trend_without_new_accumulation");
+        }
+        if (hypothesis.trigger === "CONTRADICTION" && !(changeCounts.REVISE > 0 && changeCounts.CONFIRM > 0)) {
+            reasons.push("trigger_contradiction_without_revise_confirm_pair");
+        }
+        if (hypothesis.trigger === "GAP" && changeCounts.NEW + changeCounts.REVISE < 2) {
+            reasons.push("trigger_gap_without_gap_signal");
+        }
+        if (reasons.length > 0) {
+            for (const reason of reasons)
+                rejectionReasonSet.add(reason);
+            continue;
+        }
+        acceptedHypotheses.push(hypothesis);
+    }
+    return {
+        acceptedHypotheses,
+        gate: {
+            accepted: acceptedHypotheses.length,
+            rejected: Math.max(0, args.hypotheses.length - acceptedHypotheses.length),
+            rejectionReasons: [...rejectionReasonSet].slice(0, MAX_HYPOTHESIS_REJECTION_REASONS),
+        },
+    };
+}
+function toDayStartMs(day) {
+    const ts = Date.parse(`${day}T00:00:00.000Z`);
+    return Number.isFinite(ts) ? ts : undefined;
+}
+function deriveTriggerState(args) {
+    const sorted = [...args.recentChangeStats].sort((a, b) => b.day.localeCompare(a.day));
+    // consecutive days from latest day with NEW/REVISE > 0
+    let consecutiveNewReviseDays = 0;
+    let expectedDayMs;
+    for (const item of sorted) {
+        const dayMs = toDayStartMs(item.day);
+        if (dayMs === undefined)
+            continue;
+        const hasSignal = item.newCount > 0 || item.reviseCount > 0;
+        if (!hasSignal)
+            break;
+        if (expectedDayMs === undefined) {
+            consecutiveNewReviseDays = 1;
+            expectedDayMs = dayMs - 24 * 60 * 60 * 1000;
+            continue;
+        }
+        if (dayMs === expectedDayMs) {
+            consecutiveNewReviseDays += 1;
+            expectedDayMs = dayMs - 24 * 60 * 60 * 1000;
+            continue;
+        }
+        break;
+    }
+    const sevenDaysAgo = args.nowMs - 7 * 24 * 60 * 60 * 1000;
+    let bridgeCount7d = 0;
+    for (const item of sorted) {
+        const dayMs = toDayStartMs(item.day);
+        if (dayMs === undefined)
+            continue;
+        if (dayMs < sevenDaysAgo)
+            continue;
+        bridgeCount7d += Math.max(0, Math.floor(item.bridgeCount));
+    }
+    return {
+        consecutiveNewReviseDays,
+        bridgeCount7d,
+        unreadCoreBacklog: Math.max(0, Math.floor(args.unreadCoreBacklog)),
+        lastUpdatedAtMs: args.nowMs,
+    };
+}
 export async function commitKnowledgeRun(input) {
     const project = await resolveProjectContext({
         projectId: input.projectId,
@@ -706,7 +1135,7 @@ export async function commitKnowledgeRun(input) {
         const explorationTrace = (knowledgeState.explorationTrace ?? [])
             .map(normalizeTrace)
             .filter((item) => Boolean(item));
-        const knowledgeChanges = (knowledgeState.knowledgeChanges ?? [])
+        const submittedKnowledgeChanges = (knowledgeState.knowledgeChanges ?? [])
             .map(normalizeChange)
             .filter((item) => Boolean(item));
         const knowledgeUpdates = (knowledgeState.knowledgeUpdates ?? [])
@@ -733,10 +1162,12 @@ export async function commitKnowledgeRun(input) {
                 topic: normalizeText(input.topic),
                 topicKey: streamKey,
                 projectId: project.projectId,
+                lastRunProfile: defaultRunProfile(),
                 totalRuns: 0,
                 totalHypotheses: 0,
                 knowledgeTopics: [],
                 paperNotes: [],
+                triggerState: defaultTriggerState(),
                 recentFullTextReadCount: 0,
                 recentNotFullTextReadCount: 0,
                 lastQualityGate: defaultQualityGateState(),
@@ -747,14 +1178,16 @@ export async function commitKnowledgeRun(input) {
                 recentHypotheses: [],
                 recentChangeStats: [],
                 lastExplorationTrace: [],
+                lastReflectionTasks: [],
+                lastHypothesisGate: defaultHypothesisGateState(),
             };
         const paperIds = mergePapers(corePapers, explorationPapers)
             .map((paper) => paper.id || paper.url || paper.title || "")
             .map((value) => normalizeText(value))
             .filter((value) => value.length > 0);
-        const runId = input.runId?.trim()
-            ? sanitizeId(input.runId)
-            : buildRunFingerprint({
+        const explicitRunId = input.runId?.trim() ? sanitizeId(input.runId) : undefined;
+        let runId = explicitRunId ??
+            buildRunFingerprint({
                 scope: stream.scope,
                 topic: stream.topic,
                 status: input.status,
@@ -762,15 +1195,30 @@ export async function commitKnowledgeRun(input) {
                 paperIds,
                 note: input.note,
             });
+        const inferredRunProfile = input.knowledgeState?.runLog?.runProfile === "strict" || input.knowledgeState?.runLog?.runProfile === "fast"
+            ? input.knowledgeState.runLog.runProfile
+            : input.knowledgeState?.runLog?.requiredCorePapers !== undefined ||
+                input.knowledgeState?.runLog?.requiredFullTextCoveragePct !== undefined
+                ? "strict"
+                : defaultRunProfile();
         if (stream.recentRunIds.includes(runId)) {
-            root.streams[streamKey] = stream;
-            return {
-                projectId: project.projectId,
-                streamKey,
-                summary: toSummary(stream),
-                runId,
-                createdProject: project.created,
-            };
+            // Preserve idempotency for fingerprint-based runs, but avoid silently dropping
+            // valid new cron cycles that accidentally reuse an explicit run_id.
+            if (!explicitRunId) {
+                root.streams[streamKey] = stream;
+                return {
+                    projectId: project.projectId,
+                    streamKey,
+                    summary: toSummary(stream),
+                    runId,
+                    createdProject: project.created,
+                };
+            }
+            const collisionTag = createHash("sha1")
+                .update(`${nowMs}\n${paperIds.join("|")}\n${input.status ?? ""}\n${input.note ?? ""}`)
+                .digest("hex")
+                .slice(0, 8);
+            runId = `${runId}-r${collisionTag}`;
         }
         const rootPath = getKnowledgeStateRoot(project.projectPath);
         const logDir = path.join(rootPath, "logs");
@@ -785,15 +1233,48 @@ export async function commitKnowledgeRun(input) {
             trace: explorationTrace,
             papers: explorationPapers,
         }));
-        await appendMarkdown(path.join(dailyDir, `day-${dayKey}.md`), renderDailyChangesMarkdown({ now: nowIso, runId, topic: stream.topic, changes: knowledgeChanges }));
         const mergedRunPapers = mergePapers(corePapers, explorationPapers);
+        const changeSanitization = sanitizeKnowledgeChanges({
+            changes: submittedKnowledgeChanges,
+            allRunPapers: mergedRunPapers,
+        });
+        const knowledgeChanges = changeSanitization.changes;
+        await appendMarkdown(path.join(dailyDir, `day-${dayKey}.md`), renderDailyChangesMarkdown({ now: nowIso, runId, topic: stream.topic, changes: knowledgeChanges }));
+        const reflectionTasks = deriveReflectionTasks({
+            topic: stream.topic,
+            changes: knowledgeChanges,
+            trace: explorationTrace,
+            corePapers,
+        });
+        await appendMarkdown(path.join(logDir, `day-${dayKey}-reflection.md`), renderReflectionLogMarkdown({
+            now: nowIso,
+            runId,
+            tasks: reflectionTasks,
+        }));
+        const submittedHypotheses = hypotheses;
+        const hypothesisEval = applyHypothesisGate({
+            hypotheses: submittedHypotheses,
+            allRunPapers: mergedRunPapers,
+            knowledgeChanges,
+            runProfile: inferredRunProfile,
+        });
+        const acceptedHypotheses = hypothesisEval.acceptedHypotheses;
         const qualityEval = applyQualityGates({
             corePapers,
             allRunPapers: mergedRunPapers,
+            explorationTrace,
+            reflectionTasks,
             knowledgeChanges,
             knowledgeUpdates,
-            hypotheses,
+            hypotheses: acceptedHypotheses,
+            hypothesisGate: hypothesisEval.gate,
+            requiredCorePapers: input.knowledgeState?.runLog?.requiredCorePapers,
+            requiredFullTextCoveragePct: input.knowledgeState?.runLog?.requiredFullTextCoveragePct,
         });
+        if (changeSanitization.droppedBridgeCount > 0) {
+            qualityEval.qualityGate.passed = false;
+            qualityEval.qualityGate.reasons.push(`bridge_dropped_due_to_ungrounded_evidence(${changeSanitization.droppedBridgeCount})`);
+        }
         const requestedStatus = normalizeText(input.status ?? "ok");
         const qualitySensitiveStatus = requestedStatus === "ok" || requestedStatus === "fallback_representative";
         const effectiveStatus = qualitySensitiveStatus && !qualityEval.qualityGate.passed ? "degraded_quality" : requestedStatus;
@@ -836,7 +1317,7 @@ export async function commitKnowledgeRun(input) {
         const recentHypothesisSummaries = [];
         let seq = stream.totalHypotheses;
         const dayToken = dayKey.replace(/-/g, "");
-        for (const hypothesis of hypotheses) {
+        for (const hypothesis of acceptedHypotheses) {
             seq += 1;
             const hypothesisId = hypothesis.id && hypothesis.id.length > 0 ? sanitizeId(hypothesis.id) : `hyp-${dayToken}-${String(seq).padStart(4, "0")}`;
             const file = `${hypothesisId}.md`;
@@ -854,6 +1335,7 @@ export async function commitKnowledgeRun(input) {
         await writeFile(path.join(knowledgeDir, "_index.md"), renderKnowledgeIndexMarkdown({
             now: nowIso,
             topic: stream.topic,
+            runProfile: inferredRunProfile,
             topicFiles: stream.knowledgeTopics,
             paperNotesCount: stream.paperNotes.length,
             totalHypotheses: stream.totalHypotheses + recentHypothesisSummaries.length,
@@ -862,10 +1344,13 @@ export async function commitKnowledgeRun(input) {
             notFullTextReadCount: fullTextStats.notFullTextReadCount,
             qualityGate: qualityEval.qualityGate,
             unreadCorePaperIds: qualityEval.unreadCorePaperIds,
+            reflectionTasks,
+            hypothesisGate: hypothesisEval.gate,
             lastStatus: effectiveStatus,
         }), "utf-8");
         const changeStat = countChangeStats(dayKey, runId, knowledgeChanges);
         stream.projectId = project.projectId;
+        stream.lastRunProfile = inferredRunProfile;
         stream.totalRuns += 1;
         stream.totalHypotheses += recentHypothesisSummaries.length;
         stream.lastRunAtMs = nowMs;
@@ -875,6 +1360,8 @@ export async function commitKnowledgeRun(input) {
         stream.lastQualityGate = qualityEval.qualityGate;
         stream.lastUnreadCorePaperIds = qualityEval.unreadCorePaperIds;
         stream.lastExplorationTrace = explorationTrace.slice(0, MAX_LAST_TRACE);
+        stream.lastReflectionTasks = reflectionTasks.slice(0, MAX_LAST_REFLECTION_TASKS);
+        stream.lastHypothesisGate = hypothesisEval.gate;
         stream.recentPapers = mergePapers(mergedRunPapers, stream.recentPapers).slice(0, MAX_RECENT_PAPERS);
         stream.recentRunIds = [runId, ...stream.recentRunIds.filter((id) => id !== runId)].slice(0, MAX_RECENT_RUN_IDS);
         stream.recentHypothesisIds = [
@@ -883,11 +1370,18 @@ export async function commitKnowledgeRun(input) {
         ].slice(0, MAX_RECENT_HYPOTHESES);
         stream.recentHypotheses = [...recentHypothesisSummaries, ...stream.recentHypotheses].slice(0, MAX_RECENT_HYPOTHESES);
         stream.recentChangeStats = [changeStat, ...stream.recentChangeStats].slice(0, MAX_RECENT_CHANGE_STATS);
+        stream.triggerState = deriveTriggerState({
+            recentChangeStats: stream.recentChangeStats,
+            unreadCoreBacklog: qualityEval.unreadCorePaperIds.length,
+            nowMs,
+        });
         root.streams[streamKey] = stream;
         await saveStateAtomic(project.projectPath, root);
         await appendFile(path.join(logDir, `day-${dayKey}-run-details.jsonl`), `${JSON.stringify({
             ts: nowMs,
+            run_id: runId,
             runId,
+            run_profile: inferredRunProfile,
             scope: stream.scope,
             topic: stream.topic,
             streamKey,
@@ -895,9 +1389,14 @@ export async function commitKnowledgeRun(input) {
             corePapers,
             explorationPapers,
             explorationTrace,
+            reflectionTasks,
+            submittedKnowledgeChanges,
             knowledgeChanges,
+            droppedBridgeCount: changeSanitization.droppedBridgeCount,
             knowledgeUpdates,
-            hypotheses,
+            hypotheses: acceptedHypotheses,
+            submittedHypotheses,
+            hypothesisGate: hypothesisEval.gate,
             paperNoteFiles: runPaperNoteFiles,
             quality: {
                 fullTextReadCount: fullTextStats.fullTextReadCount,
@@ -913,7 +1412,9 @@ export async function commitKnowledgeRun(input) {
         })}\n`, "utf-8");
         await appendEvent(project.projectPath, {
             ts: nowMs,
+            run_id: runId,
             runId,
+            run_profile: inferredRunProfile,
             scope: stream.scope,
             topic: stream.topic,
             streamKey,
@@ -929,8 +1430,14 @@ export async function commitKnowledgeRun(input) {
             qualityGate: qualityEval.qualityGate,
             unreadCorePaperIds: qualityEval.unreadCorePaperIds,
             downgradedHighConfidenceCount: qualityEval.downgradedHighConfidenceCount,
+            submittedChangeCount: submittedKnowledgeChanges.length,
             changeCount: knowledgeChanges.length,
+            droppedBridgeCount: changeSanitization.droppedBridgeCount,
             hypothesisCount: recentHypothesisSummaries.length,
+            submittedHypothesisCount: submittedHypotheses.length,
+            hypothesisGate: hypothesisEval.gate,
+            triggerState: stream.triggerState,
+            reflectionTasks,
             corePapers,
             explorationPapers,
             note: input.note,