scientify 1.13.5 → 2.0.0

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

@@ -2,49 +2,20 @@ 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, renderReflectionLogMarkdown, renderTopicUpdateMarkdown, slugifyTopic, } from "./render.js";
+import { dayKeyFromTimestamp, renderDailyChangesMarkdown, renderExplorationLogMarkdown, renderHypothesisMarkdown, renderIngestLogMarkdown, renderKnowledgeIndexMarkdown, renderPaperNoteHeaderMarkdown, renderPaperNoteRunMarkdown, 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 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 MIN_HYPOTHESIS_STRENGTHS = 2;
-const MIN_HYPOTHESIS_WEAKNESSES = 2;
-const MIN_HYPOTHESIS_PLAN_STEPS = 3;
-const MIN_HYPOTHESIS_STRICT_ACCEPT_SCORE = 70;
-const MIN_HYPOTHESIS_ACCEPT_SELF_SCORE_AVG = 3.2;
-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,
@@ -52,26 +23,9 @@ 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()
@@ -152,9 +106,6 @@ 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)
@@ -163,26 +114,6 @@ 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,
@@ -192,60 +123,27 @@ async function loadState(projectPath) {
                 lastQualityGate: rawStream.lastQualityGate &&
                     typeof rawStream.lastQualityGate === "object" &&
                     !Array.isArray(rawStream.lastQualityGate)
-                    ? (() => {
-                        const reasons = Array.isArray(rawStream.lastQualityGate.reasons)
+                    ? {
+                        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)
                             ? 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
@@ -269,23 +167,7 @@ async function loadState(projectPath) {
                         .map((item) => normalizeText(item))
                     : [],
                 recentHypotheses: Array.isArray(rawStream.recentHypotheses)
-                    ? rawStream.recentHypotheses.filter((item) => !!item && typeof item === "object").map((item) => ({
-                        id: sanitizeId(item.id ?? "hyp"),
-                        statement: normalizeText(item.statement ?? ""),
-                        trigger: ["GAP", "BRIDGE", "TREND", "CONTRADICTION"].includes(item.trigger)
-                            ? item.trigger
-                            : "TREND",
-                        createdAtMs: typeof item.createdAtMs === "number" && Number.isFinite(item.createdAtMs)
-                            ? item.createdAtMs
-                            : Date.now(),
-                        file: normalizeText(item.file ?? ""),
-                        ...(typeof item.strictOverallScore === "number" && Number.isFinite(item.strictOverallScore)
-                            ? { strictOverallScore: Number(item.strictOverallScore.toFixed(2)) }
-                            : {}),
-                        ...(item.strictDecision === "accept" || item.strictDecision === "revise" || item.strictDecision === "reject"
-                            ? { strictDecision: item.strictDecision }
-                            : {}),
-                    })).filter((item) => item.statement.length > 0 && item.file.length > 0)
+                    ? rawStream.recentHypotheses.filter((item) => !!item && typeof item === "object")
                     : [],
                 recentChangeStats: Array.isArray(rawStream.recentChangeStats)
                     ? rawStream.recentChangeStats.filter((item) => !!item && typeof item === "object")
@@ -296,39 +178,6 @@ 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 {
@@ -359,8 +208,8 @@ function normalizeStringArray(raw) {
         return undefined;
     const values = raw
         .filter((item) => typeof item === "string")
-        .map((item) => cleanOptionalText(item))
-        .filter((item) => Boolean(item));
+        .map((item) => normalizeText(item))
+        .filter((item) => item.length > 0);
     return values.length > 0 ? values : undefined;
 }
 function normalizeEvidenceAnchors(raw) {
@@ -369,14 +218,14 @@ function normalizeEvidenceAnchors(raw) {
     const anchors = raw
         .filter((item) => !!item && typeof item === "object")
         .map((item) => {
-        const claim = cleanOptionalText(item.claim);
+        const claim = normalizeText(item.claim ?? "");
         if (!claim)
             return undefined;
         return {
-            ...(cleanOptionalText(item.section) ? { section: cleanOptionalText(item.section) } : {}),
-            ...(cleanOptionalText(item.locator) ? { locator: cleanOptionalText(item.locator) } : {}),
+            ...(item.section ? { section: normalizeText(item.section) } : {}),
+            ...(item.locator ? { locator: normalizeText(item.locator) } : {}),
             claim,
-            ...(cleanOptionalText(item.quote) ? { quote: cleanOptionalText(item.quote) } : {}),
+            ...(item.quote ? { quote: normalizeText(item.quote) } : {}),
         };
     })
         .filter((item) => Boolean(item));
@@ -394,7 +243,7 @@ function toPaperNoteSlug(paper) {
 }
 function normalizePaper(input) {
     const evidenceIds = Array.isArray(input.evidenceIds)
-        ? input.evidenceIds.map((id) => cleanOptionalText(id)).filter((id) => Boolean(id))
+        ? input.evidenceIds.map((id) => normalizeText(id)).filter((id) => id.length > 0)
         : undefined;
     const keyEvidenceSpans = normalizeStringArray(input.keyEvidenceSpans);
     const subdomains = normalizeStringArray(input.subdomains);
@@ -415,33 +264,31 @@ function normalizePaper(input) {
             : readStatus
                 ? false
                 : undefined;
-    const unreadReason = cleanOptionalText(input.unreadReason);
+    const unreadReason = input.unreadReason ? normalizeText(input.unreadReason) : undefined;
     return {
-        ...(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) } : {}),
+        ...(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) } : {}),
         ...(typeof input.score === "number" && Number.isFinite(input.score)
             ? { score: Number(input.score.toFixed(2)) }
             : {}),
-        ...(cleanOptionalText(input.reason) ? { reason: cleanOptionalText(input.reason) } : {}),
-        ...(cleanOptionalText(input.summary) ? { summary: cleanOptionalText(input.summary) } : {}),
+        ...(input.reason ? { reason: normalizeText(input.reason) } : {}),
+        ...(input.summary ? { summary: normalizeText(input.summary) } : {}),
         ...(evidenceIds && evidenceIds.length > 0 ? { evidenceIds } : {}),
         ...(typeof fullTextRead === "boolean" ? { fullTextRead } : {}),
         ...(readStatus ? { readStatus } : {}),
-        ...(cleanOptionalText(input.fullTextSource) ? { fullTextSource: cleanOptionalText(input.fullTextSource) } : {}),
-        ...(cleanOptionalText(input.fullTextRef) ? { fullTextRef: cleanOptionalText(input.fullTextRef) } : {}),
+        ...(input.fullTextSource ? { fullTextSource: normalizeText(input.fullTextSource) } : {}),
+        ...(input.fullTextRef ? { fullTextRef: normalizeText(input.fullTextRef) } : {}),
         ...(unreadReason ? { unreadReason } : {}),
         ...(keyEvidenceSpans && keyEvidenceSpans.length > 0 ? { keyEvidenceSpans } : {}),
-        ...(cleanOptionalText(input.domain) ? { domain: cleanOptionalText(input.domain) } : {}),
+        ...(input.domain ? { domain: normalizeText(input.domain) } : {}),
         ...(subdomains ? { subdomains } : {}),
         ...(crossDomainLinks ? { crossDomainLinks } : {}),
-        ...(cleanOptionalText(input.researchGoal) ? { researchGoal: cleanOptionalText(input.researchGoal) } : {}),
-        ...(cleanOptionalText(input.approach) ? { approach: cleanOptionalText(input.approach) } : {}),
-        ...(cleanOptionalText(input.methodologyDesign)
-            ? { methodologyDesign: cleanOptionalText(input.methodologyDesign) }
-            : {}),
+        ...(input.researchGoal ? { researchGoal: normalizeText(input.researchGoal) } : {}),
+        ...(input.approach ? { approach: normalizeText(input.approach) } : {}),
+        ...(input.methodologyDesign ? { methodologyDesign: normalizeText(input.methodologyDesign) } : {}),
         ...(keyContributions ? { keyContributions } : {}),
         ...(practicalInsights ? { practicalInsights } : {}),
         ...(mustUnderstandPoints ? { mustUnderstandPoints } : {}),
@@ -554,32 +401,6 @@ 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";
 }
@@ -626,13 +447,6 @@ 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);
@@ -707,68 +521,22 @@ function applyQualityGates(args) {
             downgradedHighConfidenceCount += 1;
         }
     }
-    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})`);
-        }
-    }
+    const reasons = [];
     if (fullTextCoverage < MIN_CORE_FULLTEXT_COVERAGE) {
-        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) {
-        warnings.push(`core_fulltext_coverage_below_required(${fullTextCoveragePct}% < ${Number(args.requiredFullTextCoveragePct.toFixed(2))}%)`);
+        reasons.push(`core_fulltext_coverage_below_threshold(${fullTextCoveragePct}% < ${Number((MIN_CORE_FULLTEXT_COVERAGE * 100).toFixed(0))}%)`);
     }
     if (evidenceBindingRate < MIN_EVIDENCE_BINDING_RATE) {
-        warnings.push(`evidence_binding_rate_below_threshold(${evidenceBindingRatePct}% < ${Number((MIN_EVIDENCE_BINDING_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) {
-        warnings.push(`reflection_missing_for_bridge(bridge_count=${bridgeChangeCount})`);
+        reasons.push(`evidence_binding_rate_below_threshold(${evidenceBindingRatePct}% < ${Number((MIN_EVIDENCE_BINDING_RATE * 100).toFixed(0))}%)`);
     }
-    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) {
-        warnings.push(`hypothesis_gate_rejected_all(${args.hypothesisGate.rejected})`);
+    if (citationErrorRate >= MAX_CITATION_ERROR_RATE) {
+        reasons.push(`citation_error_rate_above_threshold(${citationErrorRatePct}% >= ${Number((MAX_CITATION_ERROR_RATE * 100).toFixed(0))}%)`);
     }
     if (downgradedHighConfidenceCount > 0) {
-        warnings.push(`high_confidence_downgraded(${downgradedHighConfidenceCount})`);
+        reasons.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: {
-            mode: "soft",
-            severity,
-            warnings,
-            fatalReasons,
-            blocking,
-            passed: !blocking,
+            passed: reasons.length === 0,
             fullTextCoveragePct,
             evidenceBindingRatePct,
             citationErrorRatePct,
@@ -778,20 +546,6 @@ function applyQualityGates(args) {
         downgradedHighConfidenceCount,
     };
 }
-function deriveEffectiveStatus(args) {
-    const requested = normalizeText(args.requestedStatus || "ok").toLowerCase();
-    if (requested === "error" || args.hasRunError)
-        return "error";
-    if (args.qualityBlocking)
-        return "degraded_quality";
-    if (requested === "empty")
-        return args.runArtifactCount > 0 ? "ok" : "empty";
-    if (requested === "degraded_quality")
-        return "ok";
-    if (requested.length === 0)
-        return args.runArtifactCount > 0 ? "ok" : "empty";
-    return requested;
-}
 function normalizeChange(input) {
     const statement = normalizeText(input.statement ?? "");
     if (!statement)
@@ -845,39 +599,12 @@ function normalizeHypothesis(input) {
         : undefined;
     const validationEvidence = normalizeStringArray(input.validationEvidence);
     const validationNotes = input.validationNotes ? normalizeText(input.validationNotes) : undefined;
-    const strengths = normalizeStringArray(input.strengths);
-    const weaknesses = normalizeStringArray(input.weaknesses);
-    const planSteps = normalizeStringArray(input.planSteps);
-    const strictEvaluationRaw = input.strictEvaluation;
-    const strictEvaluation = strictEvaluationRaw && typeof strictEvaluationRaw === "object"
-        ? (() => {
-            const overallScore = typeof strictEvaluationRaw.overallScore === "number" && Number.isFinite(strictEvaluationRaw.overallScore)
-                ? Math.max(0, Math.min(100, Number(strictEvaluationRaw.overallScore.toFixed(2))))
-                : undefined;
-            const decisionRaw = strictEvaluationRaw.decision?.trim().toLowerCase();
-            const decision = decisionRaw === "accept" || decisionRaw === "revise" || decisionRaw === "reject"
-                ? decisionRaw
-                : undefined;
-            const reason = strictEvaluationRaw.reason ? normalizeText(strictEvaluationRaw.reason) : undefined;
-            if (overallScore === undefined && !decision && !reason)
-                return undefined;
-            return {
-                ...(overallScore !== undefined ? { overallScore } : {}),
-                ...(decision ? { decision } : {}),
-                ...(reason ? { reason } : {}),
-            };
-        })()
-        : undefined;
     const withScore = (value) => typeof value === "number" && Number.isFinite(value) ? Number(value.toFixed(2)) : undefined;
     return {
         ...(input.id ? { id: sanitizeId(input.id) } : {}),
         statement,
         trigger,
         ...(dependencyPath && dependencyPath.length > 0 ? { dependencyPath } : {}),
-        ...(strengths ? { strengths } : {}),
-        ...(weaknesses ? { weaknesses } : {}),
-        ...(planSteps ? { planSteps } : {}),
-        ...(strictEvaluation ? { strictEvaluation } : {}),
         ...(typeof withScore(input.novelty) === "number" ? { novelty: withScore(input.novelty) } : {}),
         ...(typeof withScore(input.feasibility) === "number" ? { feasibility: withScore(input.feasibility) } : {}),
         ...(typeof withScore(input.impact) === "number" ? { impact: withScore(input.impact) } : {}),
@@ -915,12 +642,10 @@ 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,8 +656,6 @@ function toSummary(stream) {
         recentHypotheses: stream.recentHypotheses,
         recentChangeStats: stream.recentChangeStats,
         lastExplorationTrace: stream.lastExplorationTrace,
-        lastReflectionTasks: stream.lastReflectionTasks,
-        hypothesisGate: stream.lastHypothesisGate,
     };
 }
 function countChangeStats(day, runId, changes) {
@@ -959,448 +682,6 @@ 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 fullTextEvidenceIds = uniqueText(args.allRunPapers
-        .filter((paper) => isFullTextRead(paper))
-        .map((paper) => normalizedCitationToken(paper.id ?? paper.url ?? paper.title ?? ""))
-        .filter((id) => id.length > 0));
-    const anyEvidenceIds = uniqueText(args.allRunPapers
-        .map((paper) => normalizedCitationToken(paper.id ?? paper.url ?? paper.title ?? ""))
-        .filter((id) => id.length > 0));
-    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,
-    };
-    const evaluateHypothesisReasons = (hypothesis) => {
-        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 strengthsCount = hypothesis.strengths?.length ?? 0;
-        if (strengthsCount < MIN_HYPOTHESIS_STRENGTHS) {
-            reasons.push(`strengths_too_few(${strengthsCount}<${MIN_HYPOTHESIS_STRENGTHS})`);
-        }
-        const weaknessesCount = hypothesis.weaknesses?.length ?? 0;
-        if (weaknessesCount < MIN_HYPOTHESIS_WEAKNESSES) {
-            reasons.push(`weaknesses_too_few(${weaknessesCount}<${MIN_HYPOTHESIS_WEAKNESSES})`);
-        }
-        const planStepCount = hypothesis.planSteps?.length ?? 0;
-        if (planStepCount < MIN_HYPOTHESIS_PLAN_STEPS) {
-            reasons.push(`plan_steps_too_few(${planStepCount}<${MIN_HYPOTHESIS_PLAN_STEPS})`);
-        }
-        const hasScore = typeof hypothesis.novelty === "number" &&
-            typeof hypothesis.feasibility === "number" &&
-            typeof hypothesis.impact === "number";
-        if (!hasScore) {
-            reasons.push("missing_self_assessment_scores");
-        }
-        const strictEval = hypothesis.strictEvaluation;
-        if (!strictEval) {
-            reasons.push("missing_strict_evaluation");
-        }
-        else {
-            if (typeof strictEval.overallScore !== "number" || !Number.isFinite(strictEval.overallScore)) {
-                reasons.push("strict_evaluation_missing_overall_score");
-            }
-            if (!strictEval.decision) {
-                reasons.push("strict_evaluation_missing_decision");
-            }
-            else if (strictEval.decision !== "accept") {
-                reasons.push(`strict_evaluation_not_accept(${strictEval.decision})`);
-            }
-            if (!strictEval.reason || normalizeText(strictEval.reason).length < 16) {
-                reasons.push("strict_evaluation_reason_too_short");
-            }
-            if (strictEval.decision === "accept" &&
-                typeof strictEval.overallScore === "number" &&
-                strictEval.overallScore < MIN_HYPOTHESIS_STRICT_ACCEPT_SCORE) {
-                reasons.push(`strict_evaluation_score_below_threshold(${strictEval.overallScore}<${MIN_HYPOTHESIS_STRICT_ACCEPT_SCORE})`);
-            }
-        }
-        if (hasScore &&
-            strictEval?.decision === "accept" &&
-            ((hypothesis.novelty ?? 0) + (hypothesis.feasibility ?? 0) + (hypothesis.impact ?? 0)) / 3 <
-                MIN_HYPOTHESIS_ACCEPT_SELF_SCORE_AVG) {
-            reasons.push(`self_assessment_avg_below_accept_threshold(${Number((((hypothesis.novelty ?? 0) + (hypothesis.feasibility ?? 0) + (hypothesis.impact ?? 0)) / 3).toFixed(2))}<${MIN_HYPOTHESIS_ACCEPT_SELF_SCORE_AVG})`);
-        }
-        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");
-        }
-        return reasons;
-    };
-    const isRepairableReason = (reason) => {
-        return (reason.startsWith("dependency_path_too_short(") ||
-            reason.startsWith("strengths_too_few(") ||
-            reason.startsWith("weaknesses_too_few(") ||
-            reason.startsWith("plan_steps_too_few(") ||
-            reason === "missing_self_assessment_scores" ||
-            reason === "missing_strict_evaluation" ||
-            reason === "strict_evaluation_missing_overall_score" ||
-            reason === "strict_evaluation_missing_decision" ||
-            reason === "strict_evaluation_reason_too_short" ||
-            reason.startsWith("strict_evaluation_not_accept(") ||
-            reason.startsWith("strict_evaluation_score_below_threshold(") ||
-            reason.startsWith("insufficient_evidence_ids(") ||
-            reason.startsWith("unresolved_evidence_ids(") ||
-            reason === "no_fulltext_backed_evidence" ||
-            reason === "no_resolved_evidence");
-    };
-    const autoReviseHypothesis = (hypothesis, reasons) => {
-        if (!reasons.some((reason) => isRepairableReason(reason)))
-            return undefined;
-        const revised = {
-            ...hypothesis,
-            ...(hypothesis.dependencyPath ? { dependencyPath: [...hypothesis.dependencyPath] } : {}),
-            ...(hypothesis.strengths ? { strengths: [...hypothesis.strengths] } : {}),
-            ...(hypothesis.weaknesses ? { weaknesses: [...hypothesis.weaknesses] } : {}),
-            ...(hypothesis.planSteps ? { planSteps: [...hypothesis.planSteps] } : {}),
-            ...(hypothesis.evidenceIds ? { evidenceIds: [...hypothesis.evidenceIds] } : {}),
-            ...(hypothesis.strictEvaluation ? { strictEvaluation: { ...hypothesis.strictEvaluation } } : {}),
-        };
-        let changed = false;
-        const seedEvidence = fullTextEvidenceIds.length > 0 ? fullTextEvidenceIds : anyEvidenceIds;
-        if (seedEvidence.length > 0 && ((revised.evidenceIds?.length ?? 0) < MIN_HYPOTHESIS_EVIDENCE || reasons.some((item) => item.startsWith("unresolved_evidence_ids(") || item === "no_resolved_evidence" || item === "no_fulltext_backed_evidence"))) {
-            revised.evidenceIds = uniqueText([...(revised.evidenceIds ?? []), ...seedEvidence]).slice(0, Math.max(MIN_HYPOTHESIS_EVIDENCE, 4));
-            changed = true;
-        }
-        while ((revised.dependencyPath?.length ?? 0) < MIN_HYPOTHESIS_DEPENDENCY_STEPS) {
-            revised.dependencyPath = [
-                ...(revised.dependencyPath ?? []),
-                revised.dependencyPath && revised.dependencyPath.length > 0
-                    ? "Prior evidence accumulation provides an additional dependency step for this hypothesis."
-                    : "This hypothesis is grounded in accumulated cross-paper evidence from current run outputs.",
-            ];
-            changed = true;
-        }
-        while ((revised.strengths?.length ?? 0) < MIN_HYPOTHESIS_STRENGTHS) {
-            revised.strengths = [
-                ...(revised.strengths ?? []),
-                revised.strengths && revised.strengths.length > 0
-                    ? "The proposed idea has an explicit implementation path and measurable outcomes."
-                    : "The hypothesis is evidence-grounded and directly connected to current literature signals.",
-            ];
-            changed = true;
-        }
-        while ((revised.weaknesses?.length ?? 0) < MIN_HYPOTHESIS_WEAKNESSES) {
-            revised.weaknesses = [
-                ...(revised.weaknesses ?? []),
-                revised.weaknesses && revised.weaknesses.length > 0
-                    ? "Generality may be limited across domains without additional validation."
-                    : "Potential sensitivity to data distribution and setup assumptions.",
-            ];
-            changed = true;
-        }
-        const defaultPlanStepPool = [
-            "Implement a reproducible baseline first (include a lightweight baseline such as random forest when applicable).",
-            "Implement the proposed method and compare under matched compute/data budgets.",
-            "Run ablation and failure-case analysis, then update accept/revise/reject decision.",
-        ];
-        while ((revised.planSteps?.length ?? 0) < MIN_HYPOTHESIS_PLAN_STEPS) {
-            const idx = revised.planSteps?.length ?? 0;
-            revised.planSteps = [...(revised.planSteps ?? []), defaultPlanStepPool[Math.min(idx, defaultPlanStepPool.length - 1)]];
-            changed = true;
-        }
-        if (typeof revised.novelty !== "number" ||
-            !Number.isFinite(revised.novelty) ||
-            typeof revised.feasibility !== "number" ||
-            !Number.isFinite(revised.feasibility) ||
-            typeof revised.impact !== "number" ||
-            !Number.isFinite(revised.impact)) {
-            revised.novelty = Number((revised.novelty ?? 3.8).toFixed(2));
-            revised.feasibility = Number((revised.feasibility ?? 3.6).toFixed(2));
-            revised.impact = Number((revised.impact ?? 3.8).toFixed(2));
-            changed = true;
-        }
-        const strictOverallScore = typeof revised.strictEvaluation?.overallScore === "number" && Number.isFinite(revised.strictEvaluation.overallScore)
-            ? revised.strictEvaluation.overallScore
-            : Math.max(MIN_HYPOTHESIS_STRICT_ACCEPT_SCORE, Number((((revised.novelty ?? 3.5) + (revised.feasibility ?? 3.5) + (revised.impact ?? 3.5)) / 3 * 20).toFixed(2)));
-        const strictReason = revised.strictEvaluation?.reason && normalizeText(revised.strictEvaluation.reason).length >= 16
-            ? revised.strictEvaluation.reason
-            : "Auto-revised by hypothesis gate: structure, evidence, and execution plan now satisfy acceptance criteria.";
-        if (!revised.strictEvaluation ||
-            revised.strictEvaluation.decision !== "accept" ||
-            typeof revised.strictEvaluation.overallScore !== "number" ||
-            !Number.isFinite(revised.strictEvaluation.overallScore) ||
-            revised.strictEvaluation.overallScore < MIN_HYPOTHESIS_STRICT_ACCEPT_SCORE ||
-            normalizeText(revised.strictEvaluation.reason ?? "").length < 16) {
-            revised.strictEvaluation = {
-                overallScore: Number(Math.max(strictOverallScore, MIN_HYPOTHESIS_STRICT_ACCEPT_SCORE).toFixed(2)),
-                decision: "accept",
-                reason: strictReason,
-            };
-            changed = true;
-        }
-        return changed ? revised : undefined;
-    };
-    for (const hypothesis of args.hypotheses) {
-        const firstReasons = evaluateHypothesisReasons(hypothesis);
-        if (firstReasons.length === 0) {
-            acceptedHypotheses.push(hypothesis);
-            continue;
-        }
-        const autoRevised = autoReviseHypothesis(hypothesis, firstReasons);
-        if (autoRevised) {
-            const secondReasons = evaluateHypothesisReasons(autoRevised);
-            if (secondReasons.length === 0) {
-                acceptedHypotheses.push(autoRevised);
-                continue;
-            }
-            for (const reason of secondReasons)
-                rejectionReasonSet.add(reason);
-            continue;
-        }
-        const reasons = firstReasons;
-        if (reasons.length > 0) {
-            for (const reason of reasons)
-                rejectionReasonSet.add(reason);
-            continue;
-        }
-    }
-    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,
@@ -1425,7 +706,7 @@ export async function commitKnowledgeRun(input) {
         const explorationTrace = (knowledgeState.explorationTrace ?? [])
             .map(normalizeTrace)
             .filter((item) => Boolean(item));
-        const submittedKnowledgeChanges = (knowledgeState.knowledgeChanges ?? [])
+        const knowledgeChanges = (knowledgeState.knowledgeChanges ?? [])
             .map(normalizeChange)
             .filter((item) => Boolean(item));
         const knowledgeUpdates = (knowledgeState.knowledgeUpdates ?? [])
@@ -1452,12 +733,10 @@ 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(),
@@ -1468,16 +747,14 @@ 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 explicitRunId = input.runId?.trim() ? sanitizeId(input.runId) : undefined;
-        let runId = explicitRunId ??
-            buildRunFingerprint({
+        const runId = input.runId?.trim()
+            ? sanitizeId(input.runId)
+            : buildRunFingerprint({
                 scope: stream.scope,
                 topic: stream.topic,
                 status: input.status,
@@ -1485,30 +762,15 @@ 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)) {
-            // 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}`;
+            root.streams[streamKey] = stream;
+            return {
+                projectId: project.projectId,
+                streamKey,
+                summary: toSummary(stream),
+                runId,
+                createdProject: project.created,
+            };
         }
         const rootPath = getKnowledgeStateRoot(project.projectPath);
         const logDir = path.join(rootPath, "logs");
@@ -1523,67 +785,18 @@ export async function commitKnowledgeRun(input) {
             trace: explorationTrace,
             papers: explorationPapers,
         }));
-        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 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 mergedRunPapers = mergePapers(corePapers, explorationPapers);
         const qualityEval = applyQualityGates({
             corePapers,
             allRunPapers: mergedRunPapers,
-            explorationTrace,
-            reflectionTasks,
             knowledgeChanges,
             knowledgeUpdates,
-            hypotheses: acceptedHypotheses,
-            hypothesisGate: hypothesisEval.gate,
-            requiredCorePapers: input.knowledgeState?.runLog?.requiredCorePapers,
-            requiredFullTextCoveragePct: input.knowledgeState?.runLog?.requiredFullTextCoveragePct,
-            hasAuditableArtifacts: runArtifactCount > 0,
-            hasRunError,
+            hypotheses,
         });
-        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 effectiveStatus = deriveEffectiveStatus({
-            requestedStatus,
-            runArtifactCount,
-            hasRunError,
-            qualityBlocking: qualityEval.qualityGate.blocking,
-        });
+        const qualitySensitiveStatus = requestedStatus === "ok" || requestedStatus === "fallback_representative";
+        const effectiveStatus = qualitySensitiveStatus && !qualityEval.qualityGate.passed ? "degraded_quality" : requestedStatus;
         const topicToUpdates = new Map();
         for (const update of knowledgeUpdates) {
             const key = slugifyTopic(update.topic);
@@ -1623,7 +836,7 @@ export async function commitKnowledgeRun(input) {
         const recentHypothesisSummaries = [];
         let seq = stream.totalHypotheses;
         const dayToken = dayKey.replace(/-/g, "");
-        for (const hypothesis of acceptedHypotheses) {
+        for (const hypothesis of hypotheses) {
             seq += 1;
             const hypothesisId = hypothesis.id && hypothesis.id.length > 0 ? sanitizeId(hypothesis.id) : `hyp-${dayToken}-${String(seq).padStart(4, "0")}`;
             const file = `${hypothesisId}.md`;
@@ -1634,12 +847,6 @@ export async function commitKnowledgeRun(input) {
                 trigger: hypothesis.trigger,
                 createdAtMs: nowMs,
                 file,
-                ...(typeof hypothesis.strictEvaluation?.overallScore === "number"
-                    ? { strictOverallScore: hypothesis.strictEvaluation.overallScore }
-                    : {}),
-                ...(hypothesis.strictEvaluation?.decision
-                    ? { strictDecision: hypothesis.strictEvaluation.decision }
-                    : {}),
             });
         }
         const fullTextStats = countFullTextStats(mergedRunPapers);
@@ -1647,7 +854,6 @@ 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,
@@ -1656,13 +862,10 @@ 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;
@@ -1672,8 +875,6 @@ 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 = [
@@ -1682,18 +883,11 @@ 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,
@@ -1701,14 +895,9 @@ export async function commitKnowledgeRun(input) {
             corePapers,
             explorationPapers,
             explorationTrace,
-            reflectionTasks,
-            submittedKnowledgeChanges,
             knowledgeChanges,
-            droppedBridgeCount: changeSanitization.droppedBridgeCount,
             knowledgeUpdates,
-            hypotheses: acceptedHypotheses,
-            submittedHypotheses,
-            hypothesisGate: hypothesisEval.gate,
+            hypotheses,
             paperNoteFiles: runPaperNoteFiles,
             quality: {
                 fullTextReadCount: fullTextStats.fullTextReadCount,
@@ -1724,9 +913,7 @@ 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,
@@ -1742,14 +929,8 @@ 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,