scientify 1.13.5 → 2.0.0

package/dist/src/tools/scientify-literature-state.js

@@ -85,16 +85,6 @@ const KnowledgeHypothesisSchema = Type.Object({
     statement: Type.String({ description: "Hypothesis statement." }),
     trigger: Type.String({ description: "Trigger type: GAP|BRIDGE|TREND|CONTRADICTION." }),
     dependency_path: Type.Optional(Type.Array(Type.String({ description: "Dependency path steps." }))),
-    strengths: Type.Optional(Type.Array(Type.String({ description: "Hypothesis strengths based on current evidence." }))),
-    weaknesses: Type.Optional(Type.Array(Type.String({ description: "Hypothesis weaknesses, risks, or uncertainty points." }))),
-    plan_steps: Type.Optional(Type.Array(Type.String({ description: "Actionable research plan steps for execution." }))),
-    strict_evaluation: Type.Optional(Type.Object({
-        overall_score: Type.Optional(Type.Number({ description: "Strict overall score (0-100)." })),
-        decision: Type.Optional(Type.String({
-            description: "Strict decision: accept | revise | reject.",
-        })),
-        reason: Type.Optional(Type.String({ description: "Why this decision is made." })),
-    })),
     novelty: Type.Optional(Type.Number({ description: "Optional novelty score." })),
     feasibility: Type.Optional(Type.Number({ description: "Optional feasibility score." })),
     impact: Type.Optional(Type.Number({ description: "Optional impact score." })),
@@ -107,15 +97,10 @@ const KnowledgeHypothesisSchema = Type.Object({
 });
 const KnowledgeRunLogSchema = Type.Object({
     model: Type.Optional(Type.String({ description: "Optional model name." })),
-    run_profile: Type.Optional(Type.String({
-        description: "Optional run profile: fast | strict.",
-    })),
     duration_ms: Type.Optional(Type.Number({ description: "Optional run duration in ms." })),
     error: Type.Optional(Type.String({ description: "Optional run error text." })),
     degraded: Type.Optional(Type.Boolean({ description: "Whether this run used degraded behavior." })),
     notes: Type.Optional(Type.String({ description: "Optional extra notes." })),
-    required_core_papers: Type.Optional(Type.Number({ description: "Optional hard requirement for minimum core papers in this run." })),
-    required_full_text_coverage_pct: Type.Optional(Type.Number({ description: "Optional hard requirement for minimum full-text coverage percentage." })),
     temp_full_text_dir: Type.Optional(Type.String({ description: "Temporary local directory for full-text files." })),
     temp_files_downloaded: Type.Optional(Type.Number({ description: "Number of temporary full-text files downloaded." })),
     temp_cleanup_status: Type.Optional(Type.String({
@@ -124,22 +109,6 @@ const KnowledgeRunLogSchema = Type.Object({
     temp_cleanup_note: Type.Optional(Type.String({ description: "Optional cleanup note/error." })),
     full_text_attempted: Type.Optional(Type.Number({ description: "Number of papers attempted for full-text read." })),
     full_text_completed: Type.Optional(Type.Number({ description: "Number of papers successfully full-text read." })),
-    recall_tier_stats: Type.Optional(Type.Object({
-        tier_a: Type.Optional(Type.Object({
-            candidates: Type.Number(),
-            selected: Type.Number(),
-        })),
-        tier_b: Type.Optional(Type.Object({
-            candidates: Type.Number(),
-            selected: Type.Number(),
-        })),
-        tier_c: Type.Optional(Type.Object({
-            candidates: Type.Number(),
-            selected: Type.Number(),
-        })),
-    })),
-    reflection_step_executed: Type.Optional(Type.Boolean({ description: "Whether one reflection follow-up query was executed." })),
-    reflection_step_result_count: Type.Optional(Type.Number({ description: "Number of papers added by reflection step." })),
 });
 const KnowledgeStateSchema = Type.Optional(Type.Object({
     core_papers: Type.Optional(Type.Array(KnowledgePaperSchema)),
@@ -173,15 +142,6 @@ export const ScientifyLiteratureStateToolSchema = Type.Object({
     run_id: Type.Optional(Type.String({
         description: "Optional cron run/session id for traceability.",
     })),
-    run_profile: Type.Optional(Type.String({
-        description: "Optional run profile override: fast | strict.",
-    })),
-    required_core_papers: Type.Optional(Type.Number({
-        description: "Optional hard requirement for minimum core papers in this run.",
-    })),
-    required_full_text_coverage_pct: Type.Optional(Type.Number({
-        description: "Optional hard requirement for minimum core full-text coverage in this run.",
-    })),
     note: Type.Optional(Type.String({
         description: "Optional note for this record.",
     })),
@@ -208,12 +168,6 @@ function readStringParam(params, key) {
     const trimmed = value.trim();
     return trimmed.length > 0 ? trimmed : undefined;
 }
-function readNumberParam(params, key) {
-    const value = params[key];
-    if (typeof value !== "number" || !Number.isFinite(value))
-        return undefined;
-    return value;
-}
 function readPreferences(params) {
     const raw = params.preferences;
     if (!raw || typeof raw !== "object" || Array.isArray(raw))
@@ -595,49 +549,6 @@ function readKnowledgeStatePayload(params) {
                     .map((v) => v.trim())
                     .filter((v) => v.length > 0)
                 : undefined;
-            const strengthsRaw = row.strengths;
-            const strengths = Array.isArray(strengthsRaw)
-                ? strengthsRaw
-                    .filter((v) => typeof v === "string")
-                    .map((v) => v.trim())
-                    .filter((v) => v.length > 0)
-                : undefined;
-            const weaknessesRaw = row.weaknesses;
-            const weaknesses = Array.isArray(weaknessesRaw)
-                ? weaknessesRaw
-                    .filter((v) => typeof v === "string")
-                    .map((v) => v.trim())
-                    .filter((v) => v.length > 0)
-                : undefined;
-            const planStepsRaw = row.plan_steps ?? row.planSteps;
-            const planSteps = Array.isArray(planStepsRaw)
-                ? planStepsRaw
-                    .filter((v) => typeof v === "string")
-                    .map((v) => v.trim())
-                    .filter((v) => v.length > 0)
-                : undefined;
-            const strictEvaluationRaw = row.strict_evaluation ?? row.strictEvaluation;
-            const strictEvaluation = strictEvaluationRaw && typeof strictEvaluationRaw === "object" && !Array.isArray(strictEvaluationRaw)
-                ? (() => {
-                    const evalRow = strictEvaluationRaw;
-                    const overallScoreRaw = evalRow.overall_score ?? evalRow.overallScore;
-                    const overallScore = typeof overallScoreRaw === "number" && Number.isFinite(overallScoreRaw)
-                        ? Math.max(0, Math.min(100, Number(overallScoreRaw.toFixed(2))))
-                        : undefined;
-                    const decisionRaw = typeof evalRow.decision === "string" ? String(evalRow.decision).trim().toLowerCase() : undefined;
-                    const decision = decisionRaw === "accept" || decisionRaw === "revise" || decisionRaw === "reject"
-                        ? decisionRaw
-                        : undefined;
-                    const reason = typeof evalRow.reason === "string" ? evalRow.reason.trim() : undefined;
-                    if (overallScore === undefined && !decision && !reason)
-                        return undefined;
-                    return {
-                        ...(overallScore !== undefined ? { overallScore } : {}),
-                        ...(decision ? { decision } : {}),
-                        ...(reason ? { reason } : {}),
-                    };
-                })()
-                : undefined;
             const evidenceRaw = row.evidence_ids ?? row.evidenceIds;
             const evidenceIds = Array.isArray(evidenceRaw)
                 ? evidenceRaw
@@ -670,10 +581,6 @@ function readKnowledgeStatePayload(params) {
                 statement,
                 trigger,
                 ...(dependencyPath && dependencyPath.length > 0 ? { dependencyPath } : {}),
-                ...(strengths && strengths.length > 0 ? { strengths } : {}),
-                ...(weaknesses && weaknesses.length > 0 ? { weaknesses } : {}),
-                ...(planSteps && planSteps.length > 0 ? { planSteps } : {}),
-                ...(strictEvaluation ? { strictEvaluation } : {}),
                 ...(evidenceIds && evidenceIds.length > 0 ? { evidenceIds } : {}),
                 ...(validationStatus ? { validationStatus } : {}),
                 ...(validationNotes ? { validationNotes } : {}),
@@ -689,25 +596,11 @@ function readKnowledgeStatePayload(params) {
         ? (() => {
             const runLogRecord = runLogRaw;
             const model = typeof runLogRecord.model === "string" ? runLogRecord.model.trim() : undefined;
-            const runProfileRaw = typeof (runLogRecord.run_profile ?? runLogRecord.runProfile) === "string"
-                ? String(runLogRecord.run_profile ?? runLogRecord.runProfile).trim().toLowerCase()
-                : undefined;
-            const runProfile = runProfileRaw === "fast" || runProfileRaw === "strict"
-                ? runProfileRaw
-                : undefined;
             const durationMsRaw = runLogRecord.duration_ms ?? runLogRecord.durationMs;
             const durationMs = typeof durationMsRaw === "number" && Number.isFinite(durationMsRaw) ? durationMsRaw : undefined;
             const error = typeof runLogRecord.error === "string" ? runLogRecord.error.trim() : undefined;
             const degraded = runLogRecord.degraded === true;
             const notes = typeof runLogRecord.notes === "string" ? runLogRecord.notes.trim() : undefined;
-            const requiredCorePapersRaw = runLogRecord.required_core_papers ?? runLogRecord.requiredCorePapers;
-            const requiredCorePapers = typeof requiredCorePapersRaw === "number" && Number.isFinite(requiredCorePapersRaw)
-                ? Math.max(0, Math.floor(requiredCorePapersRaw))
-                : undefined;
-            const requiredFullTextCoveragePctRaw = runLogRecord.required_full_text_coverage_pct ?? runLogRecord.requiredFullTextCoveragePct;
-            const requiredFullTextCoveragePct = typeof requiredFullTextCoveragePctRaw === "number" && Number.isFinite(requiredFullTextCoveragePctRaw)
-                ? Math.max(0, Math.min(100, Number(requiredFullTextCoveragePctRaw.toFixed(2))))
-                : undefined;
             const tempFullTextDir = typeof (runLogRecord.temp_full_text_dir ?? runLogRecord.tempFullTextDir) === "string"
                 ? String(runLogRecord.temp_full_text_dir ?? runLogRecord.tempFullTextDir).trim()
                 : undefined;
@@ -732,85 +625,31 @@ function readKnowledgeStatePayload(params) {
             const fullTextCompleted = typeof fullTextCompletedRaw === "number" && Number.isFinite(fullTextCompletedRaw)
                 ? fullTextCompletedRaw
                 : undefined;
-            const recallTierStatsRaw = runLogRecord.recall_tier_stats ?? runLogRecord.recallTierStats;
-            const normalizeTierStat = (raw) => {
-                if (!raw || typeof raw !== "object" || Array.isArray(raw))
-                    return undefined;
-                const record = raw;
-                const candidatesRaw = record.candidates;
-                const selectedRaw = record.selected;
-                const candidates = typeof candidatesRaw === "number" && Number.isFinite(candidatesRaw)
-                    ? Math.max(0, Math.floor(candidatesRaw))
-                    : undefined;
-                const selected = typeof selectedRaw === "number" && Number.isFinite(selectedRaw)
-                    ? Math.max(0, Math.floor(selectedRaw))
-                    : undefined;
-                if (candidates === undefined && selected === undefined)
-                    return undefined;
-                return {
-                    candidates: candidates ?? 0,
-                    selected: selected ?? 0,
-                };
-            };
-            const recallTierStats = recallTierStatsRaw && typeof recallTierStatsRaw === "object" && !Array.isArray(recallTierStatsRaw)
-                ? (() => {
-                    const record = recallTierStatsRaw;
-                    const tierA = normalizeTierStat(record.tier_a ?? record.tierA);
-                    const tierB = normalizeTierStat(record.tier_b ?? record.tierB);
-                    const tierC = normalizeTierStat(record.tier_c ?? record.tierC);
-                    if (!tierA && !tierB && !tierC)
-                        return undefined;
-                    return {
-                        ...(tierA ? { tierA } : {}),
-                        ...(tierB ? { tierB } : {}),
-                        ...(tierC ? { tierC } : {}),
-                    };
-                })()
-                : undefined;
-            const reflectionStepExecuted = typeof (runLogRecord.reflection_step_executed ?? runLogRecord.reflectionStepExecuted) === "boolean"
-                ? Boolean(runLogRecord.reflection_step_executed ?? runLogRecord.reflectionStepExecuted)
-                : undefined;
-            const reflectionStepResultCountRaw = runLogRecord.reflection_step_result_count ?? runLogRecord.reflectionStepResultCount;
-            const reflectionStepResultCount = typeof reflectionStepResultCountRaw === "number" && Number.isFinite(reflectionStepResultCountRaw)
-                ? Math.max(0, Math.floor(reflectionStepResultCountRaw))
-                : undefined;
             if (!model &&
-                !runProfile &&
                 durationMs === undefined &&
                 !error &&
                 !degraded &&
                 !notes &&
-                requiredCorePapers === undefined &&
-                requiredFullTextCoveragePct === undefined &&
                 !tempFullTextDir &&
                 tempFilesDownloaded === undefined &&
                 !tempCleanupStatus &&
                 !tempCleanupNote &&
                 fullTextAttempted === undefined &&
-                fullTextCompleted === undefined &&
-                !recallTierStats &&
-                reflectionStepExecuted === undefined &&
-                reflectionStepResultCount === undefined) {
+                fullTextCompleted === undefined) {
                 return undefined;
             }
             return {
                 ...(model ? { model } : {}),
-                ...(runProfile ? { runProfile } : {}),
                 ...(durationMs !== undefined ? { durationMs } : {}),
                 ...(error ? { error } : {}),
                 ...(degraded ? { degraded } : {}),
                 ...(notes ? { notes } : {}),
-                ...(requiredCorePapers !== undefined ? { requiredCorePapers } : {}),
-                ...(requiredFullTextCoveragePct !== undefined ? { requiredFullTextCoveragePct } : {}),
                 ...(tempFullTextDir ? { tempFullTextDir } : {}),
                 ...(tempFilesDownloaded !== undefined ? { tempFilesDownloaded } : {}),
                 ...(tempCleanupStatus ? { tempCleanupStatus } : {}),
                 ...(tempCleanupNote ? { tempCleanupNote } : {}),
                 ...(fullTextAttempted !== undefined ? { fullTextAttempted } : {}),
                 ...(fullTextCompleted !== undefined ? { fullTextCompleted } : {}),
-                ...(recallTierStats ? { recallTierStats } : {}),
-                ...(reflectionStepExecuted !== undefined ? { reflectionStepExecuted } : {}),
-                ...(reflectionStepResultCount !== undefined ? { reflectionStepResultCount } : {}),
             };
         })()
         : undefined;
@@ -868,95 +707,6 @@ function serializeKnowledgePaper(paper) {
         })),
     };
 }
-function serializeKnowledgeSummaryPayload(summary) {
-    return {
-        project_id: summary.projectId,
-        stream_key: summary.streamKey,
-        run_profile: summary.runProfile,
-        total_runs: summary.totalRuns,
-        total_hypotheses: summary.totalHypotheses,
-        knowledge_topics_count: summary.knowledgeTopicsCount,
-        paper_notes_count: summary.paperNotesCount,
-        trigger_state: {
-            consecutive_new_revise_days: summary.triggerState.consecutiveNewReviseDays,
-            bridge_count_7d: summary.triggerState.bridgeCount7d,
-            unread_core_backlog: summary.triggerState.unreadCoreBacklog,
-            last_updated_at_ms: summary.triggerState.lastUpdatedAtMs,
-        },
-        recent_full_text_read_count: summary.recentFullTextReadCount,
-        recent_not_full_text_read_count: summary.recentNotFullTextReadCount,
-        quality_gate: {
-            mode: summary.qualityGate.mode,
-            severity: summary.qualityGate.severity,
-            warnings: summary.qualityGate.warnings,
-            fatal_reasons: summary.qualityGate.fatalReasons,
-            blocking: summary.qualityGate.blocking,
-            passed: summary.qualityGate.passed,
-            full_text_coverage_pct: summary.qualityGate.fullTextCoveragePct,
-            evidence_binding_rate_pct: summary.qualityGate.evidenceBindingRatePct,
-            citation_error_rate_pct: summary.qualityGate.citationErrorRatePct,
-            reasons: summary.qualityGate.reasons,
-        },
-        hypothesis_gate: {
-            accepted: summary.hypothesisGate.accepted,
-            rejected: summary.hypothesisGate.rejected,
-            rejection_reasons: summary.hypothesisGate.rejectionReasons,
-        },
-        unread_core_paper_ids: summary.unreadCorePaperIds,
-        last_run_at_ms: summary.lastRunAtMs ?? null,
-        last_status: summary.lastStatus ?? null,
-        last_reflection_tasks: summary.lastReflectionTasks.map((task) => ({
-            id: task.id,
-            trigger: task.trigger,
-            reason: task.reason,
-            query: task.query,
-            priority: task.priority,
-            status: task.status,
-        })),
-        recent_papers: summary.recentPapers.map(serializeKnowledgePaper),
-    };
-}
-function defaultKnowledgeSummaryPayload(args) {
-    return {
-        project_id: args.projectId ?? null,
-        stream_key: args.streamKey ?? null,
-        run_profile: "strict",
-        total_runs: 0,
-        total_hypotheses: 0,
-        knowledge_topics_count: 0,
-        paper_notes_count: 0,
-        trigger_state: {
-            consecutive_new_revise_days: 0,
-            bridge_count_7d: 0,
-            unread_core_backlog: 0,
-            last_updated_at_ms: null,
-        },
-        recent_full_text_read_count: 0,
-        recent_not_full_text_read_count: 0,
-        quality_gate: {
-            mode: "soft",
-            severity: "warn",
-            warnings: ["knowledge_state_summary_missing"],
-            fatal_reasons: [],
-            blocking: false,
-            passed: false,
-            full_text_coverage_pct: 0,
-            evidence_binding_rate_pct: 0,
-            citation_error_rate_pct: 0,
-            reasons: ["knowledge_state_summary_missing"],
-        },
-        hypothesis_gate: {
-            accepted: 0,
-            rejected: 0,
-            rejection_reasons: [],
-        },
-        unread_core_paper_ids: [],
-        last_run_at_ms: null,
-        last_status: null,
-        last_reflection_tasks: [],
-        recent_papers: [],
-    };
-}
 export function createScientifyLiteratureStateTool() {
     return {
         label: "Scientify Literature State",
@@ -1003,38 +753,8 @@ export function createScientifyLiteratureStateTool() {
                     const papers = readPapers(params);
                     const status = readStringParam(params, "status");
                     const runId = readStringParam(params, "run_id");
-                    const runProfileRaw = readStringParam(params, "run_profile")?.toLowerCase();
-                    const requiredCorePapers = readNumberParam(params, "required_core_papers");
-                    const requiredFullTextCoveragePct = readNumberParam(params, "required_full_text_coverage_pct");
-                    const runProfile = runProfileRaw === "fast" || runProfileRaw === "strict"
-                        ? runProfileRaw
-                        : undefined;
                     const note = readStringParam(params, "note");
                     const knowledgeState = readKnowledgeStatePayload(params);
-                    const mergedRunLog = runProfile !== undefined ||
-                        requiredCorePapers !== undefined ||
-                        requiredFullTextCoveragePct !== undefined ||
-                        knowledgeState?.runLog
-                        ? {
-                            ...(knowledgeState?.runLog ?? {}),
-                            ...(!knowledgeState?.runLog?.runProfile && runProfile !== undefined
-                                ? { runProfile }
-                                : {}),
-                            ...(knowledgeState?.runLog?.requiredCorePapers === undefined && requiredCorePapers !== undefined
-                                ? { requiredCorePapers }
-                                : {}),
-                            ...(knowledgeState?.runLog?.requiredFullTextCoveragePct === undefined &&
-                                requiredFullTextCoveragePct !== undefined
-                                ? { requiredFullTextCoveragePct }
-                                : {}),
-                        }
-                        : undefined;
-                    const mergedKnowledgeState = knowledgeState || mergedRunLog
-                        ? {
-                            ...(knowledgeState ?? {}),
-                            ...(mergedRunLog ? { runLog: mergedRunLog } : {}),
-                        }
-                        : undefined;
                     const recorded = await recordIncrementalPush({
                         scope,
                         topic,
@@ -1044,14 +764,13 @@ export function createScientifyLiteratureStateTool() {
                         note,
                         papers,
                         ...(projectId ? { projectId } : {}),
-                        ...(mergedKnowledgeState ? { knowledgeState: mergedKnowledgeState } : {}),
+                        ...(knowledgeState ? { knowledgeState } : {}),
                     });
                     return Result.ok({
                         action,
                         scope: recorded.scope,
                         topic: recorded.topic,
                         topic_key: recorded.topicKey,
-                        run_id: recorded.runId,
                         preferences: {
                             max_papers: recorded.preferences.maxPapers,
                             recency_days: recorded.preferences.recencyDays,
@@ -1070,8 +789,28 @@ export function createScientifyLiteratureStateTool() {
                         pushed_at_ms: recorded.pushedAtMs,
                         project_id: recorded.projectId ?? null,
                         knowledge_state_summary: recorded.knowledgeStateSummary
-                            ? serializeKnowledgeSummaryPayload(recorded.knowledgeStateSummary)
-                            : defaultKnowledgeSummaryPayload({ projectId: recorded.projectId, streamKey: recorded.streamKey }),
+                            ? {
+                                project_id: recorded.knowledgeStateSummary.projectId,
+                                stream_key: recorded.knowledgeStateSummary.streamKey,
+                                total_runs: recorded.knowledgeStateSummary.totalRuns,
+                                total_hypotheses: recorded.knowledgeStateSummary.totalHypotheses,
+                                knowledge_topics_count: recorded.knowledgeStateSummary.knowledgeTopicsCount,
+                                paper_notes_count: recorded.knowledgeStateSummary.paperNotesCount,
+                                recent_full_text_read_count: recorded.knowledgeStateSummary.recentFullTextReadCount,
+                                recent_not_full_text_read_count: recorded.knowledgeStateSummary.recentNotFullTextReadCount,
+                                quality_gate: {
+                                    passed: recorded.knowledgeStateSummary.qualityGate.passed,
+                                    full_text_coverage_pct: recorded.knowledgeStateSummary.qualityGate.fullTextCoveragePct,
+                                    evidence_binding_rate_pct: recorded.knowledgeStateSummary.qualityGate.evidenceBindingRatePct,
+                                    citation_error_rate_pct: recorded.knowledgeStateSummary.qualityGate.citationErrorRatePct,
+                                    reasons: recorded.knowledgeStateSummary.qualityGate.reasons,
+                                },
+                                unread_core_paper_ids: recorded.knowledgeStateSummary.unreadCorePaperIds,
+                                last_run_at_ms: recorded.knowledgeStateSummary.lastRunAtMs ?? null,
+                                last_status: recorded.knowledgeStateSummary.lastStatus ?? null,
+                                recent_papers: recorded.knowledgeStateSummary.recentPapers.map(serializeKnowledgePaper),
+                            }
+                            : null,
                     });
                 }
                 if (action === "feedback") {
@@ -1125,18 +864,11 @@ export function createScientifyLiteratureStateTool() {
                         topic,
                         ...(projectId ? { projectId } : {}),
                     });
-                    const detailedPaperById = new Map((status.knowledgeStateSummary?.recentPapers ?? [])
-                        .map((paper) => [paper.id, paper])
-                        .filter((entry) => {
-                        const [id] = entry;
-                        return typeof id === "string" && id.trim().length > 0;
-                    }));
                     return Result.ok({
                         action,
                         scope: status.scope,
                         topic: status.topic,
                         topic_key: status.topicKey,
-                        latest_run_id: status.recentChangeStats[0]?.runId ?? null,
                         preferences: {
                             max_papers: status.preferences.maxPapers,
                             recency_days: status.preferences.recencyDays,
@@ -1155,20 +887,35 @@ export function createScientifyLiteratureStateTool() {
                         total_runs: status.totalRuns,
                         last_status: status.lastStatus ?? null,
                         last_pushed_at_ms: status.lastPushedAtMs ?? null,
-                        knowledge_state_missing_reason: status.knowledgeStateSummary
-                            ? null
-                            : status.knowledgeStateMissingReason ?? "project_or_stream_not_found",
                         knowledge_state_summary: status.knowledgeStateSummary
-                            ? serializeKnowledgeSummaryPayload(status.knowledgeStateSummary)
-                            : defaultKnowledgeSummaryPayload({ projectId }),
+                            ? {
+                                project_id: status.knowledgeStateSummary.projectId,
+                                stream_key: status.knowledgeStateSummary.streamKey,
+                                total_runs: status.knowledgeStateSummary.totalRuns,
+                                total_hypotheses: status.knowledgeStateSummary.totalHypotheses,
+                                knowledge_topics_count: status.knowledgeStateSummary.knowledgeTopicsCount,
+                                paper_notes_count: status.knowledgeStateSummary.paperNotesCount,
+                                recent_full_text_read_count: status.knowledgeStateSummary.recentFullTextReadCount,
+                                recent_not_full_text_read_count: status.knowledgeStateSummary.recentNotFullTextReadCount,
+                                quality_gate: {
+                                    passed: status.knowledgeStateSummary.qualityGate.passed,
+                                    full_text_coverage_pct: status.knowledgeStateSummary.qualityGate.fullTextCoveragePct,
+                                    evidence_binding_rate_pct: status.knowledgeStateSummary.qualityGate.evidenceBindingRatePct,
+                                    citation_error_rate_pct: status.knowledgeStateSummary.qualityGate.citationErrorRatePct,
+                                    reasons: status.knowledgeStateSummary.qualityGate.reasons,
+                                },
+                                unread_core_paper_ids: status.knowledgeStateSummary.unreadCorePaperIds,
+                                last_run_at_ms: status.knowledgeStateSummary.lastRunAtMs ?? null,
+                                last_status: status.knowledgeStateSummary.lastStatus ?? null,
+                                recent_papers: status.knowledgeStateSummary.recentPapers.map(serializeKnowledgePaper),
+                            }
+                            : null,
                         recent_hypotheses: status.recentHypotheses.map((item) => ({
                             id: item.id,
                             statement: item.statement,
                             trigger: item.trigger,
                             created_at_ms: item.createdAtMs,
                             file: item.file,
-                            strict_overall_score: typeof item.strictOverallScore === "number" ? item.strictOverallScore : null,
-                            strict_decision: item.strictDecision ?? null,
                         })),
                         recent_change_stats: status.recentChangeStats.map((item) => ({
                             day: item.day,
@@ -1196,19 +943,6 @@ export function createScientifyLiteratureStateTool() {
                             first_pushed_at_ms: paper.firstPushedAtMs,
                             last_pushed_at_ms: paper.lastPushedAtMs,
                             push_count: paper.pushCount,
-                            ...(detailedPaperById.has(paper.id)
-                                ? {
-                                    full_text_read: detailedPaperById.get(paper.id)?.fullTextRead ?? null,
-                                    read_status: detailedPaperById.get(paper.id)?.readStatus ?? null,
-                                    unread_reason: detailedPaperById.get(paper.id)?.unreadReason ?? null,
-                                    evidence_anchors: (detailedPaperById.get(paper.id)?.evidenceAnchors ?? []).map((anchor) => ({
-                                        section: anchor.section ?? null,
-                                        locator: anchor.locator ?? null,
-                                        claim: anchor.claim,
-                                        quote: anchor.quote ?? null,
-                                    })),
-                                }
-                                : {}),
                         })),
                     });
                 }