scientify 1.12.1 → 1.12.2

package/dist/src/templates/bootstrap.js

@@ -13,36 +13,25 @@ export function renderBootstrapMd(projectName) {
 2. 根据用户回答，提取：
    - 核心域关键词（3-5 个）
    - 建议的 arXiv 分类（如 cs.LG, cs.AI）
-   - 建议的监测带相邻领域分类
+   - 建议的跨域探索方向（反射带）
 3. 向用户确认以上配置，接受调整
 4. 确认后执行以下写入操作：
    - 更新 SOUL.md：填写研究方向、核心域、监测带各字段
-   - 生成 metabolism/config.json（参考下方模板）
-5. 询问用户是否立即执行 Day 0（构建初始知识状态 K(T0)）
-   - 如果是，使用 arxiv_search 按配置的关键词检索论文，执行 skills/metabolism/SKILL.md 中的四步循环
+   - 生成 task.json（记录 topic / mode / created）
+5. 询问用户是否立即执行首轮研究（持续研究引擎）
+   - 如果是，执行 prepare -> collect/filter -> reflect -> record -> status
+   - 研究状态写入 knowledge_state/
 6. 删除本文件（BOOTSTRAP.md）
 
-## config.json 模板
+## task.json 模板
 
 \`\`\`json
 {
   "projectId": "${projectName}",
-  "coreQuery": {
-    "keywords": ["关键词1", "关键词2"],
-    "arxivCategories": ["cs.LG"],
-    "dateMode": "daily-new"
-  },
-  "monitorZone": {
-    "categories": ["相邻领域分类"],
-    "enabled": true
-  },
-  "heartbeat": {
-    "cronExpression": "0 6 * * *",
-    "timezone": "Asia/Shanghai",
-    "enabled": true
-  },
-  "agentId": "research-${projectName}",
-  "currentDay": 0,
+  "topic": "由用户确认后的研究主题",
+  "coreKeywords": ["关键词1", "关键词2"],
+  "monitorKeywords": ["跨域探索关键词"],
+  "mode": "continuous-research-engine",
   "createdAt": "${new Date().toISOString()}"
 }
 \`\`\`
@@ -75,14 +64,13 @@ export function renderAgentsMd() {
 $W/
 ├── SOUL.md                      # 身份 + 研究方向
 ├── AGENTS.md                    # 本文档
-├── metabolism/                  # 知识新陈代谢
-│   ├── config.json              # 项目配置（关键词、分类、heartbeat）
-│   ├── knowledge/               # K(t) 持久知识状态
-│   │   ├── _index.md            # 全景索引
-│   │   └── topic-*.md           # 主题文件（上限 50）
-│   ├── diffs/                   # 每日 diff 报告
-│   ├── hypotheses/              # 生成的假设
-│   └── log/                     # 运行日志
+├── knowledge_state/             # 持续研究状态真源（唯一）
+│   ├── knowledge/
+│   ├── daily_changes/
+│   ├── hypotheses/
+│   ├── logs/
+│   ├── state.json
+│   └── events.jsonl
 ├── survey/                      # /research-collect outputs
 │   ├── search_terms.json
 │   └── report.md
@@ -102,14 +90,13 @@ $W/
 ├── iterations/                  # /research-review: 审查迭代
 │   └── judge_v*.md
 ├── experiment_res.md            # /research-experiment: 实验报告
-└── skills/                      # workspace skills (metabolism 等)
 \`\`\`
 
 ## Session Context
 
 你可能在不同类型的 session 中被唤醒：
 - **Main session**：与人类直接对话，可触发 research-pipeline 等编排 skill
-- **Cron session**：定时触发，执行周期性任务（如每日 metabolism）
+- **Cron session**：定时触发，执行周期性研究心跳
 - **Spawn session**：被 main session 调度（sessions_spawn），执行一次性重任务
 
 任务指令会在 session 启动时注入，按指令执行即可。
@@ -123,7 +110,7 @@ $W/
 产出文件一旦写入不修改，除非用户明确要求。例外：\`project/\` 在 implement-review 迭代中可变。
 
 ### Knowledge File Rules
-- knowledge/ 下的文件是持久知识状态，修改需谨慎
+- knowledge_state/ 下的文件是持久知识状态，修改需谨慎
 - 每次修改必须先读取当前内容再更新
 - _index.md 是全景索引，必须与 topic 文件保持同步
 - topic 文件数上限 50，低活跃主题应合并归档

package/dist/src/templates/bootstrap.js.map

@@ -1 +1 @@
-{"version":3,"file":"bootstrap.js","sourceRoot":"","sources":["../../../src/templates/bootstrap.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,UAAU,iBAAiB,CAAC,WAAmB;IACnD,OAAO;;YAEG,WAAW;;;;kBAIL,WAAW;;;;;;;;;;;;;;;;;kBAiBX,WAAW;;;;;;;;;;;;;;;yBAeJ,WAAW;;kBAElB,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;;;CAGzC,CAAC;AACF,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,WAAmB;IAC9C,OAAO,qBAAqB,WAAW;;OAElC,WAAW;;;;;;;;;;;CAWjB,CAAC;AACF,CAAC;AAED,MAAM,UAAU,cAAc;IAC5B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmFR,CAAC;AACF,CAAC"}
+{"version":3,"file":"bootstrap.js","sourceRoot":"","sources":["../../../src/templates/bootstrap.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,UAAU,iBAAiB,CAAC,WAAmB;IACnD,OAAO;;YAEG,WAAW;;;;kBAIL,WAAW;;;;;;;;;;;;;;;;;;kBAkBX,WAAW;;;;;kBAKX,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;;;CAGzC,CAAC;AACF,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,WAAmB;IAC9C,OAAO,qBAAqB,WAAW;;OAElC,WAAW;;;;;;;;;;;CAWjB,CAAC;AACF,CAAC;AAED,MAAM,UAAU,cAAc;IAC5B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiFR,CAAC;AACF,CAAC"}

package/dist/src/tools/scientify-cron.d.ts

@@ -1,6 +1,6 @@
 import type { PluginLogger, PluginRuntime } from "openclaw";
 export declare const ScientifyCronToolSchema: import("@sinclair/typebox").TObject<{
-    action: import("@sinclair/typebox").TString;
+    action: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     scope: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     schedule: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     topic: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
@@ -19,6 +19,7 @@ export declare const ScientifyCronToolSchema: import("@sinclair/typebox").TObjec
     channel: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     to: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     no_deliver: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    metadata_only: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
     run_now: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
     job_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
 }>;
@@ -31,7 +32,7 @@ export declare function createScientifyCronTool(deps: CronToolDeps): {
     name: string;
     description: string;
     parameters: import("@sinclair/typebox").TObject<{
-        action: import("@sinclair/typebox").TString;
+        action: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
         scope: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
         schedule: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
         topic: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
@@ -50,6 +51,7 @@ export declare function createScientifyCronTool(deps: CronToolDeps): {
         channel: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
         to: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
         no_deliver: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+        metadata_only: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
         run_now: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
         job_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     }>;

package/dist/src/tools/scientify-cron.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scientify-cron.d.ts","sourceRoot":"","sources":["../../../src/tools/scientify-cron.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAA6C,YAAY,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AASvG,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;EAyFlC,CAAC;AAEH,KAAK,YAAY,GAAG;IAClB,OAAO,EAAE,aAAa,CAAC;IACvB,MAAM,EAAE,YAAY,CAAC;CACtB,CAAC;AAwLF,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAWzB,MAAM,WAAW,OAAO;;;;;;;;EAuFxD"}
+{"version":3,"file":"scientify-cron.d.ts","sourceRoot":"","sources":["../../../src/tools/scientify-cron.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAA6C,YAAY,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAevG,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;EAiGlC,CAAC;AAEH,KAAK,YAAY,GAAG;IAClB,OAAO,EAAE,aAAa,CAAC;IACvB,MAAM,EAAE,YAAY,CAAC;CACtB,CAAC;AAobF,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAWzB,MAAM,WAAW,OAAO;;;;;;;;EAuNxD"}

package/dist/src/tools/scientify-cron.js

@@ -1,11 +1,13 @@
 import { Type } from "@sinclair/typebox";
-import { normalizeDeliveryChannelOverride } from "../research-subscriptions/delivery.js";
+import { buildStateScopeKey, normalizeDeliveryChannelOverride, resolveDeliveryTarget, } from "../research-subscriptions/delivery.js";
+import { parseSubscribeOptions } from "../research-subscriptions/parse.js";
 import { createResearchSubscribeHandler, createResearchSubscriptionsHandler, createResearchUnsubscribeHandler, } from "../research-subscriptions.js";
+import { getIncrementalStateStatus, recordIncrementalPush } from "../literature/subscription-state.js";
 import { Result } from "./result.js";
 export const ScientifyCronToolSchema = Type.Object({
-    action: Type.String({
-        description: 'Action: "upsert" | "list" | "remove".',
-    }),
+    action: Type.Optional(Type.String({
+        description: 'Action: "upsert" | "list" | "remove". When omitted, tool infers action from parameters.',
+    })),
     scope: Type.Optional(Type.String({
         description: "Scope key for grouping jobs (e.g. user ID or thread ID). Default: global.",
     })),
@@ -48,8 +50,11 @@ export const ScientifyCronToolSchema = Type.Object({
     no_deliver: Type.Optional(Type.Boolean({
         description: "If true, run in background without push delivery.",
     })),
+    metadata_only: Type.Optional(Type.Boolean({
+        description: "If true, allow metadata-only reading (skip full-text-first strict default). Use only when user explicitly requests it.",
+    })),
     run_now: Type.Optional(Type.Boolean({
-        description: "If true (upsert only), trigger one immediate run after job creation/update and return the run result handle.",
+        description: "If true (upsert only), trigger one immediate run after job creation/update; for research tasks, also return a status_json snapshot.",
     })),
     job_id: Type.Optional(Type.String({
         description: "Specific job id to remove (only used when action=remove).",
@@ -64,6 +69,78 @@ function readStringParam(params, key) {
     const str = String(value).trim();
     return str.length > 0 ? str : undefined;
 }
+function sanitizeProjectId(raw) {
+    const trimmed = raw.trim();
+    if (/^[A-Za-z0-9_-]+$/.test(trimmed))
+        return trimmed;
+    const slug = trimmed
+        .toLowerCase()
+        .replace(/[^a-z0-9_-]+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "");
+    return slug || "project";
+}
+function normalizeScheduleInput(raw, runNow) {
+    if (!raw)
+        return undefined;
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return undefined;
+    const lower = trimmed.toLowerCase();
+    if (["now", "immediate", "immediately", "right now", "asap", "立即", "马上", "立刻"].includes(lower)) {
+        // run_now already triggers immediate execution; keep a valid persistent schedule.
+        return runNow ? "daily 09:00 Asia/Shanghai" : "at 2m";
+    }
+    if (/^\d+[smhdw]$/i.test(trimmed)) {
+        return `at ${trimmed}`;
+    }
+    if (/^every\s*hour$/i.test(trimmed) || /^每小时$/u.test(trimmed)) {
+        return "every 1h";
+    }
+    // Guard against `at <past-time>` generated by model/tool callers.
+    if (lower.startsWith("at ")) {
+        const when = trimmed.slice(3).trim();
+        if (when) {
+            const atMs = Date.parse(when);
+            if (!Number.isNaN(atMs) && atMs <= Date.now()) {
+                return runNow ? "daily 09:00 Asia/Shanghai" : "at 2m";
+            }
+        }
+    }
+    return trimmed;
+}
+function inferAction(params) {
+    const raw = readStringParam(params, "action")?.toLowerCase();
+    if (raw) {
+        if (["upsert", "create", "add", "set", "update", "start", "schedule", "new", "insert"].includes(raw)) {
+            return "upsert";
+        }
+        if (["list", "show", "ls", "status"].includes(raw)) {
+            return "list";
+        }
+        if (["remove", "delete", "cancel", "rm", "unsubscribe"].includes(raw)) {
+            return "remove";
+        }
+    }
+    const hasJobId = Boolean(readStringParam(params, "job_id"));
+    const hasUpsertSignals = Boolean(readStringParam(params, "schedule")) ||
+        Boolean(readStringParam(params, "topic")) ||
+        Boolean(readStringParam(params, "message")) ||
+        Boolean(readStringParam(params, "project")) ||
+        readBooleanParam(params, "run_now") ||
+        readBooleanParam(params, "no_deliver") ||
+        readBooleanParam(params, "metadata_only") ||
+        readNumberParam(params, "max_papers") !== undefined ||
+        readNumberParam(params, "recency_days") !== undefined ||
+        readNumberParam(params, "candidate_pool") !== undefined ||
+        Boolean(readStringParam(params, "channel")) ||
+        Boolean(readStringParam(params, "to"));
+    if (hasUpsertSignals)
+        return "upsert";
+    if (hasJobId)
+        return "remove";
+    return "list";
+}
 function readBooleanParam(params, key) {
     return params[key] === true;
 }
@@ -155,22 +232,179 @@ function deriveTopicFromResearchMessage(message) {
     const normalized = text.trim();
     return normalized.length > 0 ? normalized : message.trim();
 }
-function buildSubscribeArgs(params) {
-    const parts = [];
-    const schedule = readStringParam(params, "schedule") ?? "daily 09:00 Asia/Shanghai";
-    parts.push(schedule);
+function resolveTopicAndMessage(params) {
     let topic = readStringParam(params, "topic");
     let message = readStringParam(params, "message");
     if (!topic && message && shouldPromoteMessageToTopic(message)) {
         topic = deriveTopicFromResearchMessage(message);
         message = undefined;
     }
+    return { topic, message };
+}
+function parseIncrementalScopeFromResultText(text) {
+    const fenced = text.match(/Incremental Scope:\s*`([^`]+)`/i);
+    if (fenced?.[1])
+        return fenced[1].trim();
+    const plain = text.match(/Incremental Scope:\s*([^\n]+)/i);
+    if (plain?.[1])
+        return plain[1].trim();
+    return undefined;
+}
+function latestRunId(status) {
+    return status?.recentChangeStats[0]?.runId;
+}
+function lastRunAtMs(status) {
+    return status?.knowledgeStateSummary?.lastRunAtMs ?? 0;
+}
+function lastPushedAtMs(status) {
+    return status?.lastPushedAtMs ?? 0;
+}
+function hasFreshRun(before, after) {
+    const beforeRunId = latestRunId(before);
+    const afterRunId = latestRunId(after);
+    if (!before) {
+        return after.totalRuns > 0 || Boolean(afterRunId) || lastRunAtMs(after) > 0 || lastPushedAtMs(after) > 0;
+    }
+    if (after.totalRuns > before.totalRuns)
+        return true;
+    if (afterRunId && beforeRunId && afterRunId !== beforeRunId)
+        return true;
+    if (!beforeRunId && afterRunId)
+        return true;
+    if (lastRunAtMs(after) > lastRunAtMs(before))
+        return true;
+    if (lastPushedAtMs(after) > lastPushedAtMs(before))
+        return true;
+    return false;
+}
+function buildFallbackRunId(jobId) {
+    const ts = new Date().toISOString().replace(/[-:.]/g, "").replace("T", "t").replace("Z", "z");
+    return `cron-${jobId}-${ts}-autofallback`;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function parseCronRunMarker(raw) {
+    const text = (raw ?? "").trim();
+    if (!text)
+        return undefined;
+    try {
+        const parsed = JSON.parse(text);
+        return {
+            ok: typeof parsed.ok === "boolean" ? parsed.ok : undefined,
+            ran: typeof parsed.ran === "boolean" ? parsed.ran : undefined,
+            reason: typeof parsed.reason === "string" ? parsed.reason : undefined,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function serializeRunStatusSnapshot(status) {
+    const projectRecentPapers = status.knowledgeStateSummary?.recentPapers ?? [];
+    const globalById = new Map(status.recentPapers.map((paper) => [paper.id, paper]));
+    return {
+        scope: status.scope,
+        topic: status.topic,
+        topic_key: status.topicKey,
+        known_paper_count: status.knownPaperCount,
+        total_runs: status.totalRuns,
+        last_status: status.lastStatus ?? null,
+        last_pushed_at_ms: status.lastPushedAtMs ?? null,
+        latest_run_id: status.recentChangeStats[0]?.runId ?? null,
+        knowledge_state_summary: status.knowledgeStateSummary
+            ? {
+                project_id: status.knowledgeStateSummary.projectId,
+                stream_key: status.knowledgeStateSummary.streamKey,
+                run_profile: status.knowledgeStateSummary.runProfile,
+                total_runs: status.knowledgeStateSummary.totalRuns,
+                total_hypotheses: status.knowledgeStateSummary.totalHypotheses,
+                knowledge_topics_count: status.knowledgeStateSummary.knowledgeTopicsCount,
+                paper_notes_count: status.knowledgeStateSummary.paperNotesCount,
+                trigger_state: {
+                    consecutive_new_revise_days: status.knowledgeStateSummary.triggerState.consecutiveNewReviseDays,
+                    bridge_count_7d: status.knowledgeStateSummary.triggerState.bridgeCount7d,
+                    unread_core_backlog: status.knowledgeStateSummary.triggerState.unreadCoreBacklog,
+                    last_updated_at_ms: status.knowledgeStateSummary.triggerState.lastUpdatedAtMs,
+                },
+                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,
+                },
+                hypothesis_gate: {
+                    accepted: status.knowledgeStateSummary.hypothesisGate.accepted,
+                    rejected: status.knowledgeStateSummary.hypothesisGate.rejected,
+                    rejection_reasons: status.knowledgeStateSummary.hypothesisGate.rejectionReasons,
+                },
+                last_reflection_tasks: status.knowledgeStateSummary.lastReflectionTasks,
+            }
+            : null,
+        recent_change_stats: status.recentChangeStats.map((item) => ({
+            day: item.day,
+            run_id: item.runId,
+            new_count: item.newCount,
+            confirm_count: item.confirmCount,
+            revise_count: item.reviseCount,
+            bridge_count: item.bridgeCount,
+        })),
+        recent_papers: (projectRecentPapers.length > 0 ? projectRecentPapers : status.recentPapers).map((paper) => {
+            const paperId = typeof paper.id === "string" ? paper.id : "";
+            const fromGlobal = paperId ? globalById.get(paperId) : undefined;
+            return {
+                id: paperId || null,
+                title: paper.title ?? null,
+                url: paper.url ?? null,
+                last_score: "lastScore" in paper && typeof paper.lastScore === "number"
+                    ? paper.lastScore
+                    : "score" in paper && typeof paper.score === "number"
+                        ? paper.score
+                        : fromGlobal?.lastScore ?? null,
+                last_reason: "lastReason" in paper && typeof paper.lastReason === "string"
+                    ? paper.lastReason
+                    : "reason" in paper && typeof paper.reason === "string"
+                        ? paper.reason
+                        : fromGlobal?.lastReason ?? null,
+                first_pushed_at_ms: "firstPushedAtMs" in paper && typeof paper.firstPushedAtMs === "number"
+                    ? paper.firstPushedAtMs
+                    : fromGlobal?.firstPushedAtMs ?? null,
+                last_pushed_at_ms: "lastPushedAtMs" in paper && typeof paper.lastPushedAtMs === "number"
+                    ? paper.lastPushedAtMs
+                    : fromGlobal?.lastPushedAtMs ?? null,
+                push_count: "pushCount" in paper && typeof paper.pushCount === "number"
+                    ? paper.pushCount
+                    : fromGlobal?.pushCount ?? null,
+            };
+        }),
+        global_recent_papers: status.recentPapers.map((paper) => ({
+            id: paper.id,
+            title: paper.title ?? null,
+            url: paper.url ?? null,
+            last_score: paper.lastScore ?? null,
+            last_reason: paper.lastReason ?? null,
+            first_pushed_at_ms: paper.firstPushedAtMs,
+            last_pushed_at_ms: paper.lastPushedAtMs,
+            push_count: paper.pushCount,
+        })),
+        knowledge_state_missing_reason: status.knowledgeStateMissingReason ?? null,
+    };
+}
+function buildSubscribeArgs(params) {
+    const parts = [];
+    const schedule = normalizeScheduleInput(readStringParam(params, "schedule"), readBooleanParam(params, "run_now")) ??
+        "daily 09:00 Asia/Shanghai";
+    parts.push(schedule);
+    const resolved = resolveTopicAndMessage(params);
+    const topic = resolved.topic;
+    const message = resolved.message;
     if (topic) {
         parts.push("--topic", quoteArg(topic));
     }
     const project = readStringParam(params, "project");
     if (project) {
-        parts.push("--project", quoteArg(project));
+        parts.push("--project", quoteArg(sanitizeProjectId(project)));
     }
     if (message) {
         parts.push("--message", quoteArg(message));
@@ -212,6 +446,9 @@ function buildSubscribeArgs(params) {
     if (readBooleanParam(params, "no_deliver")) {
         parts.push("--no-deliver");
     }
+    if (readBooleanParam(params, "metadata_only")) {
+        parts.push("--metadata-only");
+    }
     return parts.join(" ");
 }
 export function createScientifyCronTool(deps) {
@@ -225,12 +462,32 @@ export function createScientifyCronTool(deps) {
         parameters: ScientifyCronToolSchema,
         execute: async (_toolCallId, rawArgs) => {
             const params = rawArgs;
-            const action = (readStringParam(params, "action") ?? "").toLowerCase();
+            const action = inferAction(params);
+            if (!action) {
+                return Result.err("invalid_params", 'Unable to infer action. Use one of: action="upsert" | "list" | "remove".');
+            }
             const scope = normalizeScope(readStringParam(params, "scope"));
             try {
                 if (action === "upsert") {
-                    const args = buildSubscribeArgs(params);
+                    // In tool context, delivery target may be unavailable unless caller explicitly sets channel/to.
+                    // Default to no-deliver when delivery is unspecified to avoid hard failure on creation.
+                    const hasDeliveryHints = Boolean(readStringParam(params, "channel")) || Boolean(readStringParam(params, "to"));
+                    const upsertParams = readBooleanParam(params, "no_deliver") || hasDeliveryHints ? params : { ...params, no_deliver: true };
+                    const args = buildSubscribeArgs(upsertParams);
                     const ctx = buildToolContext(scope, args, `/research-subscribe ${args}`);
+                    let expectedStateScopeKey;
+                    try {
+                        const parsed = parseSubscribeOptions(args);
+                        if (!("error" in parsed)) {
+                            const delivery = resolveDeliveryTarget(ctx, parsed);
+                            if (!("error" in delivery)) {
+                                expectedStateScopeKey = buildStateScopeKey(ctx, delivery);
+                            }
+                        }
+                    }
+                    catch {
+                        // keep best-effort behavior; fallback to parsed text scope or caller scope
+                    }
                     const res = await subscribe(ctx);
                     const err = getResultError(res);
                     if (err) {
@@ -238,15 +495,109 @@ export function createScientifyCronTool(deps) {
                     }
                     const text = getResultText(res);
                     const jobId = parseJobIdFromResultText(text);
-                    const runNow = readBooleanParam(params, "run_now");
+                    const resolved = resolveTopicAndMessage(upsertParams);
+                    const incrementalScope = parseIncrementalScopeFromResultText(text);
+                    const project = readStringParam(upsertParams, "project");
+                    const runNow = readBooleanParam(upsertParams, "run_now");
                     if (runNow && jobId) {
-                        let runRes = await deps.runtime.system.runCommandWithTimeout(["openclaw", "cron", "run", jobId, "--json"], { timeoutMs: 120_000 });
+                        const statusScope = expectedStateScopeKey ?? incrementalScope ?? scope;
+                        const beforeStatus = resolved.topic
+                            ? await getIncrementalStateStatus({
+                                scope: statusScope,
+                                topic: resolved.topic,
+                                ...(project ? { projectId: project } : {}),
+                            }).catch(() => undefined)
+                            : undefined;
+                        const runArgsPrimary = [
+                            "openclaw",
+                            "cron",
+                            "run",
+                            jobId,
+                            "--expect-final",
+                            "--timeout",
+                            "900000",
+                        ];
+                        let runRes = await deps.runtime.system.runCommandWithTimeout(runArgsPrimary, {
+                            timeoutMs: 920_000,
+                        });
                         if (runRes.code !== 0 &&
-                            /unknown option '--json'|unknown option \"--json\"|unknown option\s+--json/i.test(runRes.stderr || "")) {
-                            runRes = await deps.runtime.system.runCommandWithTimeout(["openclaw", "cron", "run", jobId], { timeoutMs: 120_000 });
+                            /unknown option '--expect-final'|unknown option \"--expect-final\"|unknown option\s+--expect-final/i.test(runRes.stderr || "")) {
+                            // Backward compatibility for older OpenClaw versions.
+                            runRes = await deps.runtime.system.runCommandWithTimeout(["openclaw", "cron", "run", jobId], { timeoutMs: 600_000 });
                         }
+                        let runAlreadyInProgress = false;
                         if (runRes.code !== 0) {
-                            return Result.err("operation_failed", runRes.stderr || `cron run failed for job ${jobId}`);
+                            const marker = parseCronRunMarker(runRes.stdout) ?? parseCronRunMarker(runRes.stderr);
+                            if (marker?.ok === true && marker?.ran === false && marker?.reason === "already-running") {
+                                runAlreadyInProgress = true;
+                            }
+                            else {
+                                return Result.err("operation_failed", runRes.stderr || runRes.stdout || `cron run failed for job ${jobId}`);
+                            }
+                        }
+                        let statusSnapshot;
+                        if (resolved.topic) {
+                            try {
+                                let status;
+                                const deadline = Date.now() + (runAlreadyInProgress ? 300_000 : 120_000);
+                                while (Date.now() <= deadline) {
+                                    const fetched = await getIncrementalStateStatus({
+                                        scope: statusScope,
+                                        topic: resolved.topic,
+                                        ...(project ? { projectId: project } : {}),
+                                    }).catch(() => undefined);
+                                    if (fetched && hasFreshRun(beforeStatus, fetched)) {
+                                        status = fetched;
+                                        break;
+                                    }
+                                    await sleep(1_000);
+                                }
+                                if (!status) {
+                                    const fallbackError = "run_now completed but no new persisted research run was detected. Auto-persisted fallback error run.";
+                                    try {
+                                        const persisted = await recordIncrementalPush({
+                                            scope: statusScope,
+                                            topic: resolved.topic,
+                                            ...(project ? { projectId: project } : {}),
+                                            status: "degraded_quality",
+                                            runId: buildFallbackRunId(jobId),
+                                            note: fallbackError,
+                                            papers: [],
+                                            knowledgeState: {
+                                                corePapers: [],
+                                                explorationPapers: [],
+                                                explorationTrace: [],
+                                                knowledgeChanges: [],
+                                                knowledgeUpdates: [],
+                                                hypotheses: [],
+                                                runLog: {
+                                                    runProfile: readBooleanParam(upsertParams, "metadata_only") ? "fast" : "strict",
+                                                    error: "run_now completed but the agent turn did not persist via scientify_literature_state.record",
+                                                    notes: "Fallback persisted by scientify_cron_job guard to avoid stale status response.",
+                                                    tempCleanupStatus: "not_needed",
+                                                },
+                                            },
+                                        });
+                                        status = await getIncrementalStateStatus({
+                                            scope: statusScope,
+                                            topic: resolved.topic,
+                                            ...(project ? { projectId: project } : {}),
+                                        }).catch(() => undefined);
+                                        if (!status || !hasFreshRun(beforeStatus, status)) {
+                                            return Result.err("operation_failed", `${fallbackError} fallback_run_id=${persisted.runId}, but fresh status still unavailable.`);
+                                        }
+                                    }
+                                    catch (persistError) {
+                                        return Result.err("operation_failed", `run_now completed but no new persisted research run was detected. Refusing stale status response. fallback_persist_error=${persistError instanceof Error ? persistError.message : String(persistError)}`);
+                                    }
+                                }
+                                statusSnapshot = serializeRunStatusSnapshot(status);
+                            }
+                            catch (statusError) {
+                                statusSnapshot = {
+                                    error: statusError instanceof Error ? statusError.message : String(statusError),
+                                };
+                            }
                         }
                         return Result.ok({
                             action,
@@ -254,6 +605,7 @@ export function createScientifyCronTool(deps) {
                             job_id: jobId,
                             run_now: true,
                             run_result: runRes.stdout.trim(),
+                            ...(statusSnapshot ? { status_json: statusSnapshot } : {}),
                             result: text,
                         });
                     }