@researai/deepscientist 1.5.8 → 1.5.11

package/src/deepscientist/doctor.py

@@ -265,7 +265,8 @@ def _check_codex(config_manager: ConfigManager) -> dict[str, Any]:
             errors=[f"Runner binary `{binary}` could not be resolved."],
             guidance=[
                 "Run `npm install -g @researai/deepscientist` again so the bundled Codex dependency is installed.",
-                "Then run `codex` once and complete login.",
+                "If `codex` is still missing, install it explicitly with `npm install -g @openai/codex`.",
+                "Then run `codex --login` (or `codex`) once and complete login.",
             ],
             details={"binary": binary},
         )
@@ -285,7 +286,9 @@ def _check_codex(config_manager: ConfigManager) -> dict[str, Any]:
             details={"resolved_binary": resolved_binary},
         )
     if not probe_guidance:
-        probe_guidance = ["Run `codex` manually once and complete login, then retry `ds doctor`."]
+        probe_guidance = [
+            "Run `codex --login` (or `codex`) manually once and complete login, then retry `ds doctor`.",
+        ]
     return _make_check(
         check_id="codex",
         label="Codex CLI",

package/src/deepscientist/gitops/diff.py

@@ -299,45 +299,41 @@ def _collect_branch_state(repo: Path) -> dict[str, dict[str, Any]]:
             continue
         state = branch_state[branch_name]
         state.setdefault("branch", branch_name)
-        state["updated_at"] = record.get("updated_at") or state.get("updated_at")
-        if record.get("kind") == "run":
-            state["run_id"] = record.get("run_id") or state.get("run_id")
-            state["run_kind"] = record.get("run_kind") or state.get("run_kind")
+        artifact_sort_key = _artifact_record_sort_key(record, path)
+        current_artifact_sort_key = state.get("_latest_artifact_sort_key")
+        if current_artifact_sort_key is None or artifact_sort_key > current_artifact_sort_key:
+            state["_latest_artifact_sort_key"] = artifact_sort_key
+            state["updated_at"] = record.get("updated_at") or record.get("created_at") or state.get("updated_at")
         if record.get("idea_id"):
             state["idea_id"] = record.get("idea_id")
         if record.get("parent_branch"):
             state["parent_branch"] = record.get("parent_branch")
         if record.get("worktree_root"):
             state["worktree_root"] = record.get("worktree_root")
-        latest_metric = extract_latest_metric(record)
+        resolved_run_result = _resolve_run_result_payload(repo, record)
+        latest_metric = extract_latest_metric(resolved_run_result if record.get("kind") == "run" else record)
         if latest_metric is not None:
             state["latest_metric"] = latest_metric
         if record.get("kind") == "run":
-            state["latest_result"] = {
-                "run_id": record.get("run_id"),
-                "run_kind": record.get("run_kind"),
-                "status": record.get("status"),
-                "summary": record.get("summary") or record.get("reason"),
-                "verdict": record.get("verdict"),
-                "paths": record.get("paths") or {},
-                "details": record.get("details") or {},
-                "metrics_summary": record.get("metrics_summary") or {},
-                "metric_rows": record.get("metric_rows") or [],
-                "metric_contract": record.get("metric_contract") or {},
-                "baseline_ref": record.get("baseline_ref") or {},
-                "baseline_comparisons": record.get("baseline_comparisons") or {},
-                "progress_eval": record.get("progress_eval") or {},
-                "evaluation_summary": record.get("evaluation_summary")
-                or ((record.get("details") or {}) if isinstance(record.get("details"), dict) else {}).get("evaluation_summary")
-                or {},
-                "files_changed": record.get("files_changed") or [],
-                "evidence_paths": record.get("evidence_paths") or [],
-                "updated_at": record.get("updated_at"),
-            }
-            state["breakthrough"] = bool(((record.get("progress_eval") or {}).get("breakthrough")))
-            state["breakthrough_level"] = ((record.get("progress_eval") or {}).get("breakthrough_level"))
+            candidate_sort_key = _run_result_sort_key(record, resolved_run_result, path)
+            current_sort_key = state.get("_latest_result_sort_key")
+            if current_sort_key is None or candidate_sort_key > current_sort_key:
+                state["_latest_result_sort_key"] = candidate_sort_key
+                state["latest_result"] = resolved_run_result
+                state["run_id"] = resolved_run_result.get("run_id") or state.get("run_id")
+                state["run_kind"] = resolved_run_result.get("run_kind") or state.get("run_kind")
+                progress_eval = (
+                    resolved_run_result.get("progress_eval")
+                    if isinstance(resolved_run_result.get("progress_eval"), dict)
+                    else {}
+                )
+                state["breakthrough"] = bool(progress_eval.get("breakthrough"))
+                state["breakthrough_level"] = progress_eval.get("breakthrough_level")
         if record.get("summary") or record.get("message") or record.get("reason"):
-            state["latest_summary"] = record.get("summary") or record.get("message") or record.get("reason")
+            current_summary_sort_key = state.get("_latest_summary_sort_key")
+            if current_summary_sort_key is None or artifact_sort_key > current_summary_sort_key:
+                state["_latest_summary_sort_key"] = artifact_sort_key
+                state["latest_summary"] = record.get("summary") or record.get("message") or record.get("reason")
         state["recent_artifacts"].append(
             {
                 "artifact_id": record.get("artifact_id"),
@@ -346,12 +342,107 @@ def _collect_branch_state(repo: Path) -> dict[str, dict[str, Any]]:
                 "reason": record.get("reason"),
                 "updated_at": record.get("updated_at"),
                 "status": record.get("status"),
+                "_sort_key": artifact_sort_key,
             }
         )
+        state["recent_artifacts"].sort(key=lambda item: item.get("_sort_key") or ("", 0, ""))
         state["recent_artifacts"] = state["recent_artifacts"][-4:]
+    for state in branch_state.values():
+        latest_result = state.get("latest_result")
+        if isinstance(latest_result, dict):
+            result_metric = extract_latest_metric(latest_result)
+            if result_metric is not None:
+                state["latest_metric"] = result_metric
+        for item in state.get("recent_artifacts", []):
+            if isinstance(item, dict):
+                item.pop("_sort_key", None)
     return branch_state
 
 
+def _resolve_run_result_payload(repo: Path, record: dict[str, Any]) -> dict[str, Any]:
+    details = dict(record.get("details") or {}) if isinstance(record.get("details"), dict) else {}
+    paths = dict(record.get("paths") or {}) if isinstance(record.get("paths"), dict) else {}
+    result_payload: dict[str, Any] = {}
+    result_json_path = _resolve_result_json_path(repo, paths.get("result_json"))
+    if result_json_path and result_json_path.exists():
+        loaded = read_json(result_json_path, {})
+        if isinstance(loaded, dict):
+            result_payload = loaded
+
+    evaluation_summary = (
+        record.get("evaluation_summary")
+        or details.get("evaluation_summary")
+        or result_payload.get("evaluation_summary")
+        or {}
+    )
+    progress_eval = record.get("progress_eval")
+    if not isinstance(progress_eval, dict):
+        progress_eval = result_payload.get("progress_eval") if isinstance(result_payload.get("progress_eval"), dict) else {}
+
+    return {
+        "run_id": record.get("run_id") or result_payload.get("run_id"),
+        "run_kind": record.get("run_kind") or result_payload.get("run_kind"),
+        "status": record.get("status") or result_payload.get("status"),
+        "summary": record.get("summary") or record.get("reason") or result_payload.get("summary"),
+        "verdict": record.get("verdict") or result_payload.get("verdict"),
+        "paths": paths or (result_payload.get("paths") if isinstance(result_payload.get("paths"), dict) else {}) or {},
+        "details": details,
+        "metrics_summary": record.get("metrics_summary") or result_payload.get("metrics_summary") or {},
+        "metric_rows": record.get("metric_rows") or result_payload.get("metric_rows") or [],
+        "metric_contract": record.get("metric_contract") or result_payload.get("metric_contract") or {},
+        "baseline_ref": record.get("baseline_ref") or result_payload.get("baseline_ref") or {},
+        "baseline_comparisons": record.get("baseline_comparisons") or result_payload.get("baseline_comparisons") or {},
+        "progress_eval": progress_eval or {},
+        "evaluation_summary": evaluation_summary or {},
+        "files_changed": record.get("files_changed") or result_payload.get("files_changed") or [],
+        "evidence_paths": record.get("evidence_paths") or result_payload.get("evidence_paths") or [],
+        "updated_at": record.get("updated_at") or result_payload.get("updated_at"),
+    }
+
+
+def _resolve_result_json_path(repo: Path, raw_path: object) -> Path | None:
+    normalized = str(raw_path or "").strip()
+    if not normalized:
+        return None
+    candidate = Path(normalized).expanduser()
+    if candidate.is_absolute():
+        return candidate
+    return repo / candidate
+
+
+def _artifact_record_sort_key(record: dict[str, Any], path: Path) -> tuple[str, int, str]:
+    updated_at = str(record.get("updated_at") or record.get("created_at") or "").strip()
+    try:
+        mtime_ns = path.stat().st_mtime_ns
+    except OSError:
+        mtime_ns = 0
+    return (updated_at, mtime_ns, str(path))
+
+
+def _run_result_sort_key(record: dict[str, Any], payload: dict[str, Any], path: Path) -> tuple[int, str, int, str]:
+    quality = 0
+    if extract_latest_metric(payload):
+        quality += 8
+    if payload.get("baseline_comparisons"):
+        quality += 4
+    if payload.get("progress_eval"):
+        quality += 4
+    if payload.get("metrics_summary"):
+        quality += 3
+    if payload.get("metric_rows"):
+        quality += 3
+    if payload.get("verdict"):
+        quality += 2
+    paths = payload.get("paths") if isinstance(payload.get("paths"), dict) else {}
+    if paths.get("result_json"):
+        quality += 2
+    if paths.get("run_md"):
+        quality += 1
+    updated_at = str(payload.get("updated_at") or record.get("updated_at") or record.get("created_at") or "")
+    _, mtime_ns, path_str = _artifact_record_sort_key(record, path)
+    return (quality, updated_at, mtime_ns, path_str)
+
+
 def _classify_ref(ref: str, state: dict[str, Any]) -> dict[str, str]:
     run_id = str(state.get("run_id") or "")
     run_kind = str(state.get("run_kind") or "")

package/src/deepscientist/lingzhu_support.py

@@ -1,182 +1 @@
-from __future__ import annotations
-
-import json
-import secrets
-from typing import Any
-from urllib.parse import urlparse
-
-
-DEFAULT_LINGZHU_GATEWAY_PORT = 18789
-DEFAULT_LINGZHU_LOCAL_HOST = "127.0.0.1"
-DEFAULT_LINGZHU_AGENT_ID = "main"
-DEFAULT_LINGZHU_SESSION_NAMESPACE = "lingzhu"
-
-_AUTH_AK_SEGMENTS = (8, 4, 4, 4, 12)
-_AUTH_AK_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789"
-
-
-def generate_lingzhu_auth_ak() -> str:
-    parts: list[str] = []
-    for segment_length in _AUTH_AK_SEGMENTS:
-        parts.append("".join(secrets.choice(_AUTH_AK_CHARS) for _ in range(segment_length)))
-    return "-".join(parts)
-
-
-def lingzhu_local_host(config: dict[str, Any] | None) -> str:
-    value = str((config or {}).get("local_host") or DEFAULT_LINGZHU_LOCAL_HOST).strip()
-    return value or DEFAULT_LINGZHU_LOCAL_HOST
-
-
-def lingzhu_gateway_port(config: dict[str, Any] | None) -> int:
-    raw = (config or {}).get("gateway_port")
-    try:
-        value = int(raw)
-    except (TypeError, ValueError):
-        return DEFAULT_LINGZHU_GATEWAY_PORT
-    if value < 1 or value > 65535:
-        return DEFAULT_LINGZHU_GATEWAY_PORT
-    return value
-
-
-def normalize_public_base_url(value: Any) -> str | None:
-    text = str(value or "").strip()
-    if not text:
-        return None
-    parsed = urlparse(text)
-    if parsed.scheme not in {"http", "https"} or not parsed.netloc:
-        return None
-    return text.rstrip("/")
-
-
-def lingzhu_local_base_url(config: dict[str, Any] | None) -> str:
-    return f"http://{lingzhu_local_host(config)}:{lingzhu_gateway_port(config)}"
-
-
-def lingzhu_public_base_url(config: dict[str, Any] | None) -> str | None:
-    return normalize_public_base_url((config or {}).get("public_base_url"))
-
-
-def lingzhu_health_url(config: dict[str, Any] | None, *, public: bool = False) -> str | None:
-    base = lingzhu_public_base_url(config) if public else lingzhu_local_base_url(config)
-    if not base:
-        return None
-    return f"{base}/metis/agent/api/health"
-
-
-def lingzhu_sse_url(config: dict[str, Any] | None, *, public: bool = False) -> str | None:
-    base = lingzhu_public_base_url(config) if public else lingzhu_local_base_url(config)
-    if not base:
-        return None
-    return f"{base}/metis/agent/api/sse"
-
-
-def lingzhu_agent_id(config: dict[str, Any] | None) -> str:
-    value = str((config or {}).get("agent_id") or DEFAULT_LINGZHU_AGENT_ID).strip()
-    return value or DEFAULT_LINGZHU_AGENT_ID
-
-
-def lingzhu_probe_payload(
-    config: dict[str, Any] | None,
-    *,
-    message_id: str = "ds-lingzhu-probe-001",
-    text: str = "你好",
-) -> dict[str, Any]:
-    return {
-        "message_id": message_id,
-        "agent_id": lingzhu_agent_id(config),
-        "message": [
-            {
-                "role": "user",
-                "type": "text",
-                "text": text,
-            }
-        ],
-    }
-
-
-def lingzhu_generated_openclaw_config(config: dict[str, Any] | None) -> dict[str, Any]:
-    resolved = dict(config or {})
-    return {
-        "gateway": {
-            "port": lingzhu_gateway_port(resolved),
-            "http": {
-                "endpoints": {
-                    "chatCompletions": {
-                        "enabled": True,
-                    }
-                }
-            },
-        },
-        "plugins": {
-            "entries": {
-                "lingzhu": {
-                    "enabled": bool(resolved.get("enabled", False)),
-                    "config": {
-                        "authAk": str(resolved.get("auth_ak") or "").strip(),
-                        "agentId": lingzhu_agent_id(resolved),
-                        "includeMetadata": bool(resolved.get("include_metadata", True)),
-                        "requestTimeoutMs": int(resolved.get("request_timeout_ms") or 60000),
-                        "systemPrompt": str(resolved.get("system_prompt") or ""),
-                        "defaultNavigationMode": str(resolved.get("default_navigation_mode") or "0"),
-                        "enableFollowUp": bool(resolved.get("enable_follow_up", True)),
-                        "followUpMaxCount": int(resolved.get("follow_up_max_count") or 3),
-                        "maxImageBytes": int(resolved.get("max_image_bytes") or 5 * 1024 * 1024),
-                        "sessionMode": str(resolved.get("session_mode") or "per_user"),
-                        "sessionNamespace": str(
-                            resolved.get("session_namespace") or DEFAULT_LINGZHU_SESSION_NAMESPACE
-                        ),
-                        "autoReceiptAck": bool(resolved.get("auto_receipt_ack", True)),
-                        "visibleProgressHeartbeat": bool(
-                            resolved.get("visible_progress_heartbeat", True)
-                        ),
-                        "visibleProgressHeartbeatSec": int(
-                            resolved.get("visible_progress_heartbeat_sec") or 10
-                        ),
-                        "debugLogging": bool(resolved.get("debug_logging", False)),
-                        "debugLogPayloads": bool(resolved.get("debug_log_payloads", False)),
-                        "debugLogDir": str(resolved.get("debug_log_dir") or ""),
-                        "enableExperimentalNativeActions": bool(
-                            resolved.get("enable_experimental_native_actions", False)
-                        ),
-                    },
-                }
-            }
-        },
-    }
-
-
-def lingzhu_generated_openclaw_config_text(config: dict[str, Any] | None) -> str:
-    return json.dumps(lingzhu_generated_openclaw_config(config), indent=2, ensure_ascii=False)
-
-
-def lingzhu_generated_curl(config: dict[str, Any] | None, *, text: str = "你好") -> str:
-    auth_ak = str((config or {}).get("auth_ak") or "").strip()
-    payload = lingzhu_probe_payload(config, text=text)
-    endpoint_url = lingzhu_sse_url(config) or ""
-    return (
-        f"curl -X POST '{endpoint_url}' \\\n"
-        f"  --header 'Authorization: Bearer {auth_ak}' \\\n"
-        "  --header 'Content-Type: application/json' \\\n"
-        f"  --data '{json.dumps(payload, ensure_ascii=False)}'"
-    )
-
-
-def lingzhu_supported_commands(*, experimental_enabled: bool) -> list[str]:
-    commands = [
-        "take_photo",
-        "take_navigation",
-        "control_calendar",
-        "notify_agent_off",
-    ]
-    if experimental_enabled:
-        commands.extend(
-            [
-                "send_notification",
-                "send_toast",
-                "speak_tts",
-                "start_video_record",
-                "stop_video_record",
-                "open_custom_view",
-            ]
-        )
-    return commands
+from .connector.lingzhu_support import *  # noqa: F401,F403

package/src/deepscientist/mcp/server.py

@@ -471,7 +471,7 @@ def build_artifact_server(context: McpContext) -> FastMCP:
             context.require_quest_root(),
             campaign_title=campaign_title,
             campaign_goal=campaign_goal,
-            parent_run_id=parent_run_id or context.run_id,
+            parent_run_id=parent_run_id,
             slices=slices,
             campaign_origin=campaign_origin,
             selected_outline_ref=selected_outline_ref,
@@ -636,6 +636,7 @@ def build_artifact_server(context: McpContext) -> FastMCP:
         summary: str | None = None,
         baseline_kind: str | None = None,
         metric_contract: dict[str, Any] | None = None,
+        metric_directions: dict[str, str] | None = None,
         metrics_summary: dict[str, Any] | None = None,
         primary_metric: dict[str, Any] | None = None,
         auto_advance: bool = True,
@@ -651,6 +652,7 @@ def build_artifact_server(context: McpContext) -> FastMCP:
                 summary=summary,
                 baseline_kind=baseline_kind,
                 metric_contract=metric_contract,
+                metric_directions=metric_directions,
                 metrics_summary=metrics_summary,
                 primary_metric=primary_metric,
                 auto_advance=auto_advance,
@@ -678,16 +680,23 @@ def build_artifact_server(context: McpContext) -> FastMCP:
     @server.tool(
         name="arxiv",
         description=(
-            "Read an identified arXiv paper by id. "
-            "Use full_text=false for the overview/abstract path and full_text=true when the full paper body is needed."
+            "Interact with the quest-local arXiv library. "
+            "Use mode='read' to read one paper by id with local-first automatic persistence, "
+            "or mode='list' to list the saved arXiv items for the current quest."
         ),
     )
     def arxiv(
-        paper_id: str,
+        paper_id: str | None = None,
+        mode: str = "read",
         full_text: bool = False,
         comment: str | dict[str, Any] | None = None,
     ) -> dict[str, Any]:
-        return service.arxiv(paper_id, full_text=full_text)
+        return service.arxiv(
+            paper_id,
+            mode=mode,
+            full_text=full_text,
+            quest_root=context.require_quest_root(),
+        )
 
     @server.tool(name="refresh_summary", description="Refresh SUMMARY.md from recent artifact state.")
     def refresh_summary(

package/src/deepscientist/prompts/builder.py

@@ -283,6 +283,21 @@ class PromptBuilder:
                     "- qq_structured_delivery_rule: when you want native QQ markdown or native QQ image/file delivery, request it through artifact.interact(connector_hints=..., attachments=[...]) instead of inventing connector-specific inline tag syntax.",
                 ]
             )
+        elif connector == "weixin":
+            lines.extend(
+                [
+                    "- weixin_surface_rule: Weixin is a concise operator surface, not a full artifact browser.",
+                    "- weixin_default_mode: keep outbound replies concise, respectful, text-first, and progress-aware.",
+                    "- weixin_length_rule: for ordinary Weixin progress replies, normally use only 2 to 4 short sentences, or 3 very short bullets at most.",
+                    "- weixin_summary_first_rule: start with the user-facing conclusion, then the immediate meaning, then the next action.",
+                    "- weixin_progress_shape_rule: make the current task, the main difficulty or latest real progress, and the next concrete next step explicit whenever possible.",
+                    "- weixin_eta_rule: for important long-running phases, include a rough ETA or next check-in window when it is helpful and defensible.",
+                    "- weixin_internal_detail_rule: do not proactively dump file inventories, path lists, retry counters, or monitor-log style telemetry unless the user asked for them or they explain a real risk.",
+                    "- weixin_context_token_rule: reply continuity is managed by the runtime through `context_token`; do not invent your own reply token scheme.",
+                    "- weixin_media_rule: when you want native Weixin image, video, or file delivery, request it through artifact.interact(..., attachments=[...]) with `connector_delivery={'weixin': {'media_kind': ...}}` instead of inventing connector-specific inline tag syntax.",
+                    "- weixin_inbound_media_rule: inbound Weixin image, video, and file messages can arrive as quest-local attachments under `userfiles/weixin/...`; read those files when the user sent media.",
+                ]
+            )
         else:
             lines.append("- connector_media_rule: if the active surface is not QQ, keep using the general artifact interaction discipline for milestone delivery.")
 
@@ -687,6 +702,8 @@ class PromptBuilder:
             f"- delivery_mode: {'paper_required' if need_research_paper else 'algorithm_first'}",
             "- idea_stage_rule: every accepted idea submission should normally create a new branch/worktree and a new user-visible research node.",
             "- idea_draft_rule: before `artifact.submit_idea(...)`, first finish a concise durable Markdown draft for the chosen route; keep `idea.md` compact and `draft.md` richer.",
+            "- idea_literature_floor_rule: before writing or submitting a final selected idea, durably survey at least 5 and usually 5 to 10 related and usable papers; prioritize direct task-modeling or mechanism-neighbor work and only backfill with the closest adjacent translatable papers when necessary.",
+            "- idea_reference_rule: the final selected-idea draft should use one consistent standard citation format and include a `References` or `Bibliography` section for the survey-stage papers that actually shaped the motivation, mechanism, or claim boundary.",
             "- lineage_rule: normal idea routing uses exactly two lineage intents: `continue_line` creates a child of the current active branch; `branch_alternative` creates a sibling-like branch from the current branch's parent foundation.",
             "- revise_rule: `artifact.submit_idea(mode='revise', ...)` is maintenance-only compatibility for the same branch and should not be the default research-route mechanism.",
             "- post_main_result_rule: after every `artifact.record_main_experiment(...)`, first interpret the measured result and only then choose the next route.",
@@ -806,6 +823,8 @@ class PromptBuilder:
             "- idea_why_now_protocol: every serious idea candidate should answer why now or what changed, not just what the mechanism is",
             "- idea_balance_protocol: when the search space is not tiny, carry at least one conservative route and one higher-upside route into the final comparison",
             "- idea_pitch_protocol: before artifact.submit_idea(...), make the winner pass a two-sentence pitch, a strongest-objection check, and a concrete why-now statement",
+            "- idea_literature_floor_protocol: do not write or submit the final selected idea until the durable survey covers at least 5 and usually 5 to 10 related and usable papers; if fewer than 5 direct papers exist, document the shortage and use the closest adjacent translatable work instead of skipping the gate",
+            "- idea_reference_protocol: the final selected-idea draft should cite the survey-stage papers it actually uses and end with a standard-format `References` or `Bibliography` section",
             "- experiment_milestone_protocol: immediately after artifact.record_main_experiment(...) writes the durable result, send a threaded milestone that explains what was run, the main result, whether primary performance improved / worsened / stayed mixed versus the active baseline or best prior anchor, whether the route still looks promising, and the exact next step",
             "- analysis_milestone_protocol: immediately after a meaningful completed analysis-campaign synthesis or route-significant campaign checkpoint, send a threaded milestone that explains which campaign question or slice set just closed, whether the claim boundary became stronger / weaker / mixed, the main caveat, and the exact next route",
             "- paper_milestone_protocol: immediately after a meaningful paper or draft milestone such as selected outline, evidence-complete draft, major revision package, or bundle-ready paper, send a threaded milestone that explains what document milestone is now complete, which claims are now supportable, what still needs strengthening, and the exact next revision or execution route",
@@ -952,7 +971,16 @@ class PromptBuilder:
         attachment_root = active_workspace_root / "baselines" / "imported"
         if attachment_root.exists():
             attachments = [read_yaml(path, {}) for path in sorted(attachment_root.glob("*/attachment.yaml"))]
-            attachments = [item for item in attachments if isinstance(item, dict) and item]
+            attachments = [
+                item
+                for item in attachments
+                if isinstance(item, dict)
+                and item
+                and (
+                    not str(item.get("source_baseline_id") or "").strip()
+                    or not self.baseline_registry.is_deleted(str(item.get("source_baseline_id") or "").strip())
+                )
+            ]
             if attachments:
                 attachment = max(
                     attachments,