scientify 1.12.1 → 1.13.0

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

@@ -16,11 +16,30 @@ 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 FATAL_CITATION_ERROR_RATE = 0.2;
+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 {
+        mode: "soft",
+        severity: "warn",
+        warnings: ["quality gate not evaluated"],
+        fatalReasons: [],
+        blocking: false,
         passed: false,
         fullTextCoveragePct: 0,
         evidenceBindingRatePct: 0,
@@ -38,6 +57,16 @@ function defaultHypothesisGateState() {
 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()
@@ -118,6 +147,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)
@@ -126,6 +158,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,
@@ -135,27 +187,60 @@ async function loadState(projectPath) {
                 lastQualityGate: rawStream.lastQualityGate &&
                     typeof rawStream.lastQualityGate === "object" &&
                     !Array.isArray(rawStream.lastQualityGate)
-                    ? {
-                        passed: rawStream.lastQualityGate.passed === true,
-                        fullTextCoveragePct: typeof rawStream.lastQualityGate.fullTextCoveragePct === "number" &&
-                            Number.isFinite(rawStream.lastQualityGate.fullTextCoveragePct)
-                            ? Number(rawStream.lastQualityGate.fullTextCoveragePct.toFixed(2))
-                            : 0,
-                        evidenceBindingRatePct: typeof rawStream.lastQualityGate.evidenceBindingRatePct === "number" &&
-                            Number.isFinite(rawStream.lastQualityGate.evidenceBindingRatePct)
-                            ? Number(rawStream.lastQualityGate.evidenceBindingRatePct.toFixed(2))
-                            : 0,
-                        citationErrorRatePct: typeof rawStream.lastQualityGate.citationErrorRatePct === "number" &&
-                            Number.isFinite(rawStream.lastQualityGate.citationErrorRatePct)
-                            ? Number(rawStream.lastQualityGate.citationErrorRatePct.toFixed(2))
-                            : 0,
-                        reasons: Array.isArray(rawStream.lastQualityGate.reasons)
+                    ? (() => {
+                        const reasons = Array.isArray(rawStream.lastQualityGate.reasons)
                             ? rawStream.lastQualityGate.reasons
                                 .filter((item) => typeof item === "string")
                                 .map((item) => normalizeText(item))
                                 .filter((item) => item.length > 0)
-                            : [],
-                    }
+                            : [];
+                        const warnings = Array.isArray(rawStream.lastQualityGate.warnings)
+                            ? rawStream.lastQualityGate.warnings
+                                .filter((item) => typeof item === "string")
+                                .map((item) => normalizeText(item))
+                                .filter((item) => item.length > 0)
+                            : reasons;
+                        const fatalReasons = Array.isArray(rawStream.lastQualityGate.fatalReasons)
+                            ? rawStream.lastQualityGate.fatalReasons
+                                .filter((item) => typeof item === "string")
+                                .map((item) => normalizeText(item))
+                                .filter((item) => item.length > 0)
+                            : [];
+                        const blocking = rawStream.lastQualityGate.blocking === true || fatalReasons.length > 0;
+                        const severityRaw = typeof rawStream.lastQualityGate.severity === "string"
+                            ? rawStream.lastQualityGate.severity.toLowerCase()
+                            : undefined;
+                        const severity = severityRaw === "fatal" || blocking
+                            ? "fatal"
+                            : severityRaw === "ok"
+                                ? "ok"
+                                : warnings.length > 0
+                                    ? "warn"
+                                    : "ok";
+                        return {
+                            mode: "soft",
+                            severity,
+                            warnings,
+                            fatalReasons,
+                            blocking,
+                            passed: typeof rawStream.lastQualityGate.passed === "boolean"
+                                ? rawStream.lastQualityGate.passed
+                                : fatalReasons.length === 0,
+                            fullTextCoveragePct: typeof rawStream.lastQualityGate.fullTextCoveragePct === "number" &&
+                                Number.isFinite(rawStream.lastQualityGate.fullTextCoveragePct)
+                                ? Number(rawStream.lastQualityGate.fullTextCoveragePct.toFixed(2))
+                                : 0,
+                            evidenceBindingRatePct: typeof rawStream.lastQualityGate.evidenceBindingRatePct === "number" &&
+                                Number.isFinite(rawStream.lastQualityGate.evidenceBindingRatePct)
+                                ? Number(rawStream.lastQualityGate.evidenceBindingRatePct.toFixed(2))
+                                : 0,
+                            citationErrorRatePct: typeof rawStream.lastQualityGate.citationErrorRatePct === "number" &&
+                                Number.isFinite(rawStream.lastQualityGate.citationErrorRatePct)
+                                ? Number(rawStream.lastQualityGate.citationErrorRatePct.toFixed(2))
+                                : 0,
+                            reasons: reasons.length > 0 ? reasons : [...warnings, ...fatalReasons],
+                        };
+                    })()
                     : defaultQualityGateState(),
                 lastUnreadCorePaperIds: Array.isArray(rawStream.lastUnreadCorePaperIds)
                     ? rawStream.lastUnreadCorePaperIds
@@ -253,8 +338,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) {
@@ -263,14 +348,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));
@@ -288,7 +373,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);
@@ -309,31 +394,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 } : {}),
@@ -446,6 +533,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";
 }
@@ -492,6 +605,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);
@@ -566,42 +686,68 @@ function applyQualityGates(args) {
             downgradedHighConfidenceCount += 1;
         }
     }
-    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)})`);
+    const warnings = [];
+    const fatalReasons = [];
+    if (!args.hasAuditableArtifacts && !args.hasRunError) {
+        fatalReasons.push("no_auditable_artifacts_without_run_error");
+    }
+    if (typeof args.requiredCorePapers === "number" && Number.isFinite(args.requiredCorePapers) && args.requiredCorePapers > 0) {
+        const requiredCore = Math.floor(args.requiredCorePapers);
+        if (coreCount === 0) {
+            fatalReasons.push(`core_paper_count_below_required(${coreCount} < ${requiredCore})`);
+        }
+        else if (coreCount < requiredCore) {
+            warnings.push(`core_paper_count_below_required(${coreCount} < ${requiredCore})`);
+        }
     }
     if (fullTextCoverage < MIN_CORE_FULLTEXT_COVERAGE) {
-        reasons.push(`core_fulltext_coverage_below_threshold(${fullTextCoveragePct}% < ${Number((MIN_CORE_FULLTEXT_COVERAGE * 100).toFixed(0))}%)`);
+        warnings.push(`core_fulltext_coverage_below_threshold(${fullTextCoveragePct}% < ${Number((MIN_CORE_FULLTEXT_COVERAGE * 100).toFixed(0))}%)`);
+    }
+    if (fullTextCorePapers.length > 0 && avgFullTextProfileCompleteness < MIN_FULLTEXT_PROFILE_COMPLETENESS) {
+        warnings.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))}%)`);
+        warnings.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))}%)`);
+        warnings.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))}%)`);
+    if (citationErrorRate >= FATAL_CITATION_ERROR_RATE) {
+        fatalReasons.push(`citation_error_rate_above_threshold(${citationErrorRatePct}% >= ${Number((FATAL_CITATION_ERROR_RATE * 100).toFixed(0))}%)`);
+    }
+    else if (citationErrorRate >= MAX_CITATION_ERROR_RATE) {
+        warnings.push(`citation_error_rate_above_warning_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})`);
+        warnings.push(`reflection_missing_for_bridge(bridge_count=${bridgeChangeCount})`);
+    }
+    if (reviseCount > 0 && confirmCount > 0 && executedReflectionCount === 0) {
+        warnings.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})`);
+        warnings.push(`hypothesis_gate_rejected_all(${args.hypothesisGate.rejected})`);
     }
     if (downgradedHighConfidenceCount > 0) {
-        reasons.push(`high_confidence_downgraded(${downgradedHighConfidenceCount})`);
+        warnings.push(`high_confidence_downgraded(${downgradedHighConfidenceCount})`);
     }
+    const reasons = [...warnings, ...fatalReasons];
+    const blocking = fatalReasons.length > 0;
+    const severity = blocking ? "fatal" : warnings.length > 0 ? "warn" : "ok";
     return {
         qualityGate: {
-            passed: reasons.length === 0,
+            mode: "soft",
+            severity,
+            warnings,
+            fatalReasons,
+            blocking,
+            passed: !blocking,
             fullTextCoveragePct,
             evidenceBindingRatePct,
             citationErrorRatePct,
@@ -707,10 +853,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,
@@ -931,9 +1079,12 @@ function applyHypothesisGate(args) {
         if (resolvedEvidence < evidenceIds.length) {
             reasons.push(`unresolved_evidence_ids(${evidenceIds.length - resolvedEvidence})`);
         }
-        if (fullTextSupported === 0) {
+        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})`);
@@ -972,6 +1123,51 @@ function applyHypothesisGate(args) {
         },
     };
 }
+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,
@@ -1023,10 +1219,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(),
@@ -1044,9 +1242,9 @@ export async function commitKnowledgeRun(input) {
             .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,
@@ -1054,15 +1252,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");
@@ -1100,8 +1313,16 @@ export async function commitKnowledgeRun(input) {
             hypotheses: submittedHypotheses,
             allRunPapers: mergedRunPapers,
             knowledgeChanges,
+            runProfile: inferredRunProfile,
         });
         const acceptedHypotheses = hypothesisEval.acceptedHypotheses;
+        const runArtifactCount = corePapers.length +
+            explorationPapers.length +
+            explorationTrace.length +
+            knowledgeChanges.length +
+            knowledgeUpdates.length +
+            submittedHypotheses.length;
+        const hasRunError = Boolean(input.knowledgeState?.runLog?.error && normalizeText(input.knowledgeState.runLog.error).length > 0);
         const qualityEval = applyQualityGates({
             corePapers,
             allRunPapers: mergedRunPapers,
@@ -1113,10 +1334,19 @@ export async function commitKnowledgeRun(input) {
             hypothesisGate: hypothesisEval.gate,
             requiredCorePapers: input.knowledgeState?.runLog?.requiredCorePapers,
             requiredFullTextCoveragePct: input.knowledgeState?.runLog?.requiredFullTextCoveragePct,
+            hasAuditableArtifacts: runArtifactCount > 0,
+            hasRunError,
         });
+        if (changeSanitization.droppedBridgeCount > 0) {
+            qualityEval.qualityGate.warnings.push(`bridge_dropped_due_to_ungrounded_evidence(${changeSanitization.droppedBridgeCount})`);
+            qualityEval.qualityGate.reasons.push(`bridge_dropped_due_to_ungrounded_evidence(${changeSanitization.droppedBridgeCount})`);
+            if (qualityEval.qualityGate.severity === "ok") {
+                qualityEval.qualityGate.severity = "warn";
+            }
+        }
         const requestedStatus = normalizeText(input.status ?? "ok");
         const qualitySensitiveStatus = requestedStatus === "ok" || requestedStatus === "fallback_representative";
-        const effectiveStatus = qualitySensitiveStatus && !qualityEval.qualityGate.passed ? "degraded_quality" : requestedStatus;
+        const effectiveStatus = qualitySensitiveStatus && qualityEval.qualityGate.blocking ? "degraded_quality" : requestedStatus;
         const topicToUpdates = new Map();
         for (const update of knowledgeUpdates) {
             const key = slugifyTopic(update.topic);
@@ -1174,6 +1404,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,
@@ -1188,6 +1419,7 @@ export async function commitKnowledgeRun(input) {
         }), "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;
@@ -1207,11 +1439,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,
@@ -1242,7 +1481,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,
@@ -1264,6 +1505,7 @@ export async function commitKnowledgeRun(input) {
             hypothesisCount: recentHypothesisSummaries.length,
             submittedHypothesisCount: submittedHypotheses.length,
             hypothesisGate: hypothesisEval.gate,
+            triggerState: stream.triggerState,
             reflectionTasks,
             corePapers,
             explorationPapers,