@delta-infra/cli 1.0.79 → 1.0.80

package/skills/delta-science/references/strbo.md

@@ -0,0 +1,87 @@
+# STRBO 详细规则
+
+STRBO 用于服务端固定 **KRAS G12D** 靶点的小分子生成式多目标优化。目标顺序固定为
+`[vina, activity]`：vina 越低越好，activity 越高越好。`task` 只引导候选生成，
+不会更换靶点；不得声称支持用户自定义受体。
+
+所有调用均使用 `tool="strbo"`。生成、建议、评估和提交 job 都会消耗远端资源，只在
+用户确实要求执行相应科研任务时调用；请求结果未知或超时时不得重试。
+
+## 初始化
+
+- 同步 operation：`molecules-init`
+- 异步 operation：`molecules-init-job`
+- 仅校验 operation：`molecules-init-validate`
+
+```json
+{
+  "task": "为 KRAS G12D 生成兼顾结合与活性的候选小分子",
+  "num_initial": 3,
+  "seed": 42
+}
+```
+
+只需检查参数时使用 validate；正式执行不要先 validate 再提交，避免无必要调用。
+成功结果应包含与 `num_initial` 数量一致的候选 SMILES。
+
+## 建议下一批候选
+
+- 同步 operation：`molecules-suggest`
+- 异步 operation：`molecules-suggest-job`（重型任务优先）
+- 仅校验 operation：`molecules-suggest-validate`
+
+```json
+{
+  "task": "继续改善 KRAS G12D 的结合与活性",
+  "history_xs": ["CCO", "CCN", "CCC"],
+  "history_ys": [
+    [-6.8, 0.31],
+    [-7.1, 0.42],
+    [-6.5, 0.28]
+  ],
+  "num_suggestions": 2,
+  "seed": 42
+}
+```
+
+`history_xs` 与 `history_ys` 必须等长；每个 `history_ys` 元素必须是两个有限数值，
+顺序严格为 `[vina, activity]`。不得把预测值伪装成湿实验结果。
+
+## 评估候选
+
+- 同步 operation：`molecules-evaluate`
+- 异步 operation：`molecules-evaluate-job`
+- 仅校验 operation：`molecules-evaluate-validate`
+
+```json
+{
+  "designs": ["CCO", "CCN"]
+}
+```
+
+成功结果中的 score 数量必须与 designs 一致，每行必须恰好有两个有限数值。任一 item
+明确失败时，本轮整体按失败处理，不得只报告成功子集。
+
+## 异步作业
+
+提交异步 operation 后，从当前 native 读取非空 `job_id`，再轮询：
+
+```python
+invoke("strbo", "job-status", params={"job_id": job_id})
+```
+
+只有状态变为 `succeeded` 后才读取：
+
+```python
+invoke("strbo", "job-result", params={"job_id": job_id})
+```
+
+`queued` 或 `running` 不是完成；`failed` 立即结束。状态查询可按 5 秒左右间隔重复，
+但提交 operation 绝不重复。单次用户任务的总等待上限为 15 分钟；超限后报告作业仍
+未完成并保留 job_id，不得声称远端已取消。
+
+## 完整科研流程
+
+用户明确要求完整迭代时按 `初始化 → 评估 → 建议 → 评估` 串行执行。每一步只使用本次
+调用已验证的 native 作为下一步输入。用户只要求生成初始候选或评估给定 SMILES 时，
+不得擅自扩展为完整循环。

package/skills/{synbo-service/references/endpoints.md → delta-science/references/synbo.md}

@@ -1,13 +1,16 @@
-# SynBO API Endpoint Reference
+# SynBO operation 参考
 
-All paths are relative to `http://111.2.199.31:52317/api/v1`.
+所有在线调用都通过 `delta-science/scripts/invoke.py` 和 Delta CLI，服务地址来自当前
+CLI 的 `science_base_url` 配置。这里的路径只说明业务 operation，不得据此直连 HTTP。
 
-This reference is for the exposed HTTP gateway. It is not a local SynBO project
-runner.
+用户说“优化反应条件”“推荐下一批实验”“偶联反应怎么继续做”，或给出溶剂、温度、
+催化剂、碱、配体和历史得率时，即使没有提到 SynBO、BO、CLI 或字段名也使用本节。
+每个用户任务最多一次 SynBO 业务调用；成功后立即结束，validation、502、504、
+timeout、断连或空 recommendations 均不得换参数、换模型或重试。
 
 ## Health
 
-`GET /chem/synbo/health`
+operation：`health`，无 body。
 
 Reports SynBO import status, Torch/CUDA runtime availability, service limits,
 default device, and visible CUDA devices.
@@ -43,7 +46,7 @@ Important fields inside gateway `data`:
 
 ## Initialize
 
-`POST /chem/synbo/initialize`
+operation：`initialize`。
 
 Use for initial condition sampling when no measured previous results exist.
 
@@ -71,7 +74,7 @@ Supported `sampling_method` values: `sobol`, `random`, `lhs`, `kmeans`.
 
 ## Optimize
 
-`POST /chem/synbo/optimize`
+operation：`optimize`。
 
 Use after measured experiment rows are available. Each previous row must contain
 all condition columns and all objective metric columns.
@@ -93,11 +96,53 @@ Request body:
   ],
   "batch_size": 2,
   "accuracy": "tiny",
+  "surrogate_model": "RF",
+  "acq_func": "UCB",
   "device": "cpu",
   "random_seed": 42
 }
 ```
 
+### 数值条件必须先离散化
+
+SynBO 的 `condition_dict` 只接受显式列表，不接受连续范围对象。对于“温度
+40–100°C、催化剂用量 0.5–2.0%”并已有 60/70/80/90°C 与
+0.5/1.0/1.5/2.0% 历史值的任务，使用：
+
+```json
+{
+  "condition_dict": {
+    "solvent": ["ethanol", "acetonitrile", "DMSO"],
+    "temperature_C": ["40", "60", "70", "80", "90", "100"],
+    "catalyst_loading_pct": ["0.5", "1.0", "1.5", "2.0"]
+  },
+  "opt_metrics": ["yield"],
+  "previous_results": [
+    {
+      "batch": 0,
+      "solvent": "ethanol",
+      "temperature_C": "60",
+      "catalyst_loading_pct": "1.0",
+      "yield": 55.0
+    }
+  ],
+  "batch_size": 3,
+  "accuracy": "tiny",
+  "surrogate_model": "RF",
+  "acq_func": "UCB",
+  "device": "cpu",
+  "random_seed": 42
+}
+```
+
+约束：
+
+- 每个条件值统一为字符串，objective metric 保持数值。
+- 每条 `previous_results` 中的条件值必须出现在对应 `condition_dict` 列表中。
+- 连续范围的离散网格必须包含用户上下界和全部历史观测值；最终答案必须说明实际网格。
+- wrapper 会在发送前完成字符串归一化、成员校验，并为未显式指定的小数据 CPU
+  `optimize` 补充 `tiny + RF + UCB + cpu` 默认值。
+
 Useful optional fields:
 
 - `accuracy`: `tiny`, `low`, `medium`, `high`, or `ultra`.
@@ -137,7 +182,6 @@ Gateway errors have the standard envelope:
   "message": "SynBO service returned HTTP 400",
   "data": {
     "endpoint": "/synbo/optimize",
-    "service_url": "http://synbo-service:8897",
     "synbo_response": {
       "detail": "previous_results is missing metric columns: ['yield']"
     }
@@ -145,13 +189,9 @@ Gateway errors have the standard envelope:
 }
 ```
 
-Common causes are oversized reaction spaces, duplicate condition values,
-non-numeric descriptors, missing previous-result columns, missing numeric metric
-values, and requesting CUDA when no GPU is available.
+常见原因包括条件空间过大、条件值重复、历史条件值不在 condition_dict 中、
+descriptor 非数值、历史行缺列、metric 非数值，以及无 GPU 时请求 CUDA。
 
-The service also enforces its own per-request time limit that is independent of
-the client HTTP `timeout`. A slow call returns a timeout error such as
-`"SynBO service timed out"`. This is expected for heavy optimizer settings
-(GP + EHVI, higher accuracy) or when a concurrent request is occupying the
-shared GPU. Retry once the service is idle, or lower `accuracy`, narrow the
-reaction space, or use a GPU device.
+服务端有独立于客户端的单次请求时限。GP、EHVI、高 accuracy 或共享资源繁忙可能导致
+timeout。普通用户任务中不得自动换参数重试；应报告“未产生推荐”，保留本次错误，
+由用户决定是否另起一次明确的回归测试。

package/skills/delta-science/references/workflows.md

@@ -1,10 +1,10 @@
 # 跨服务工作流
 
-每一步必须直接使用对应的具名 service Skill，并由该 Skill 的 `python_repl` 调用
-`delta-science/scripts/invoke.py`。禁止把步骤派发给 `task[general-purpose]`、通用
-subagent 或自由文本执行器；禁止 Bash、目录探测和直接 HTTP。wrapper 成功后每一步
-只消费 `result["native"]` 顶层。目标 operation 不在 CLI catalog 时，立即标记为
-不支持且未发送远端请求，不猜测相近 endpoint。
+整个流程由单一 `delta-science` Skill 编排。每一步都通过宿主可用的 shell/Python 调用
+当前 Skill 目录下的 `scripts/invoke.py`，禁止再派发到其他 Science Skill、通用 subagent
+或自由文本执行器；禁止直接 HTTP。wrapper 成功后每一步只消费 `result["native"]` 顶层。
+已知 reference 中没有目标 operation 时，不猜测相近
+endpoint；只有用户明确点名新工具时，才按 `SKILL.md` 的只读实时 catalog 流程确认。
 
 ## 单个已命名分子
 
@@ -37,8 +37,25 @@ subagent 或自由文本执行器；禁止 Bash、目录探测和直接 HTTP。w
 ## 优化工作流
 
 - 通用数值或分类实验变量：Delta-BO
-- 以分子结构为决策变量：LDM-BO
-- 带真实历史结果的分类反应条件：SynBO
+- 固定 SMILES 候选池或 PDF2Dock/Vina+NN 轨迹：LDM-BO
+- 固定 KRAS G12D 的生成式小分子闭环：STRBO
+- 指定抗原的 11-aa CDRH3 闭环：AntBO
+- 偶联反应、反应条件和带真实历史得率的下一批实验推荐：SynBO
+
+用户以 “LDM/大发现模型” 描述任务时，必须先按 `SKILL.md` 读取 `ldm.md`，再读取唯一
+选定后端的 reference。LDM 是工作流意图，不是 tool；禁止旧
+`large-discovery-model`、`run_ldm_loop.py`、gateway backend 和直接 HTTP。
 
 禁止为了让优化器运行而编造观测数据。用户没有提供测量结果时，只能使用初始化或随机建议模式，并明确说明它是待实验验证的建议，不是已经验证的最优条件。
 SynBO/Delta-BO 没有返回 recommendations 时，不得用本地回归、GP、UCB 或人工排序替代。
+
+SynBO 只接受离散条件列表。用户给连续范围时，在一次调用前完成以下处理：
+
+1. 条件网格包含用户上下界、全部历史观测值和少量合理中间点。
+2. 同一条件列在 `condition_dict` 与 `previous_results` 中统一为字符串。
+3. 得率等 objective metric 保持数值。
+4. 小数据 CPU 默认 `tiny + RF + UCB`，并在最终答案中报告实际离散网格。
+5. wrapper 返回失败或空 recommendations 时结束；不得连续尝试多种 payload 或模型。
+
+用户未要求文件时只返回 recommendations 文本，不创建输入 CSV。必须交接时，仅把本次
+成功 native 写入当前 `WORKSPACE_ROOT/synbo_result.json`。

package/skills/delta-science/scripts/catalog.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""Read the authoritative Delta Science catalog through delta-cli."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+import time
+
+from invoke import _parse_cli_error, _resolve_cli, _runtime_config
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    action = parser.add_mutually_exclusive_group(required=True)
+    action.add_argument("--tools", action="store_true")
+    action.add_argument("--endpoints", metavar="TOOL")
+    parser.add_argument("--cli")
+    parser.add_argument("--science-base-url")
+    parser.add_argument("--timeout", type=float, default=30.0)
+    return parser
+
+
+def main() -> int:
+    args = _parser().parse_args()
+    started = time.perf_counter()
+    kind = "tools" if args.tools else "endpoints"
+    try:
+        runtime = _runtime_config()
+        cli = _resolve_cli(args.cli, runtime)
+        env = os.environ.copy()
+        base_url = args.science_base_url or runtime.get("science_base_url")
+        if base_url:
+            env["DELTA_INFRA_SCIENCE_BASE_URL"] = str(base_url)
+
+        command = [cli, "science", "list"]
+        if args.endpoints:
+            command = [cli, "science", "endpoints", "list", args.endpoints]
+        completed = subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            env=env,
+            timeout=args.timeout,
+            check=False,
+        )
+        if completed.returncode != 0:
+            error_type, detail = _parse_cli_error(completed)
+            raise RuntimeError(f"{error_type}: {detail}")
+        root = json.loads(completed.stdout)
+        if not isinstance(root, dict) or root.get("ok") is not True:
+            raise RuntimeError(json.dumps(root, ensure_ascii=False))
+        if "data" not in root:
+            raise RuntimeError("CLI success envelope is missing data")
+        print(json.dumps({
+            "ok": True,
+            "transport": "delta-cli",
+            "catalog": kind,
+            "tool": args.endpoints,
+            "elapsed_seconds": round(time.perf_counter() - started, 3),
+            "native": root["data"],
+        }, ensure_ascii=False))
+        return 0
+    except subprocess.TimeoutExpired:
+        error_type = "timeout"
+        error = f"timeout after {args.timeout}s"
+    except (OSError, ValueError, json.JSONDecodeError) as exc:
+        error_type = "catalog"
+        error = str(exc)
+    except RuntimeError as exc:
+        error_type = "cli"
+        error = str(exc)
+
+    print(json.dumps({
+        "ok": False,
+        "transport": "delta-cli",
+        "catalog": kind,
+        "tool": args.endpoints,
+        "error_type": error_type,
+        "elapsed_seconds": round(time.perf_counter() - started, 3),
+        "error": error[:2000],
+    }, ensure_ascii=False))
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/delta-science/scripts/invoke.py

@@ -12,12 +12,17 @@ import subprocess
 import sys
 import time
 from typing import Any
-from urllib.parse import urlsplit
-
-from generated_catalog import LEGACY_ENDPOINTS, LEGACY_TOOL_ALIASES
-
 
 SKILL_DIR = Path(__file__).resolve().parents[1]
+_CLI_ERROR_TYPES = {
+    2: "validation",
+    3: "auth",
+    4: "permission",
+    5: "not_found",
+    6: "network",
+    7: "api",
+    10: "internal",
+}
 
 
 def _json_object(raw: str | None, flag: str) -> dict[str, Any] | None:
@@ -32,6 +37,108 @@ def _json_object(raw: str | None, flag: str) -> dict[str, Any] | None:
     return value
 
 
+def _normalize_synbo_payload(
+    tool: str,
+    endpoint: str,
+    data: dict[str, Any] | None,
+) -> tuple[dict[str, Any] | None, dict[str, Any] | None]:
+    """Normalize SynBO's discrete condition contract before any remote request."""
+    canonical_tool = tool.removesuffix("-service")
+    if canonical_tool != "synbo" or endpoint not in {"initialize", "optimize"}:
+        return data, None
+    if data is None:
+        raise ValueError(f"synbo/{endpoint} requires --data-json")
+
+    condition_dict = data.get("condition_dict")
+    if not isinstance(condition_dict, dict) or not condition_dict:
+        raise ValueError("SynBO condition_dict must be a non-empty object")
+
+    normalized_conditions: dict[str, list[str]] = {}
+    for name, raw_values in condition_dict.items():
+        if not isinstance(raw_values, list) or not raw_values:
+            raise ValueError(
+                f"SynBO condition_dict.{name} must be a non-empty explicit list; "
+                "range objects are not supported"
+            )
+        values = [str(value) for value in raw_values]
+        if any(value == "" for value in values):
+            raise ValueError(f"SynBO condition_dict.{name} contains an empty value")
+        if len(set(values)) != len(values):
+            raise ValueError(
+                f"SynBO condition_dict.{name} contains duplicate values after "
+                "string normalization"
+            )
+        normalized_conditions[str(name)] = values
+
+    normalized = dict(data)
+    normalized["condition_dict"] = normalized_conditions
+    normalization = {
+        "condition_values": "strings",
+        "condition_space_size": _condition_space_size(normalized_conditions),
+    }
+
+    if endpoint == "initialize":
+        return normalized, normalization
+
+    metrics = normalized.get("opt_metrics")
+    if not isinstance(metrics, list) or not metrics:
+        raise ValueError("SynBO optimize requires a non-empty opt_metrics list")
+    metric_names = [str(metric) for metric in metrics]
+    normalized["opt_metrics"] = metric_names
+
+    previous_results = normalized.get("previous_results")
+    if not isinstance(previous_results, list) or not previous_results:
+        raise ValueError("SynBO optimize requires non-empty previous_results")
+
+    normalized_rows: list[dict[str, Any]] = []
+    for index, raw_row in enumerate(previous_results):
+        if not isinstance(raw_row, dict):
+            raise ValueError(f"SynBO previous_results[{index}] must be an object")
+        row = dict(raw_row)
+        for condition_name, allowed_values in normalized_conditions.items():
+            if condition_name not in row:
+                raise ValueError(
+                    f"SynBO previous_results[{index}] is missing condition "
+                    f"{condition_name!r}"
+                )
+            value = str(row[condition_name])
+            if value not in allowed_values:
+                raise ValueError(
+                    f"SynBO previous_results[{index}].{condition_name}={value!r} "
+                    "is not present in condition_dict"
+                )
+            row[condition_name] = value
+        for metric_name in metric_names:
+            metric_value = row.get(metric_name)
+            if (
+                metric_name not in row
+                or isinstance(metric_value, bool)
+                or not isinstance(metric_value, (int, float))
+            ):
+                raise ValueError(
+                    f"SynBO previous_results[{index}].{metric_name} must be numeric"
+                )
+        normalized_rows.append(row)
+
+    normalized["previous_results"] = normalized_rows
+    normalized.setdefault("accuracy", "tiny")
+    normalized.setdefault("device", "cpu")
+    normalized.setdefault("surrogate_model", "RF")
+    normalized.setdefault("acq_func", "UCB")
+    normalization["defaults"] = {
+        key: normalized[key]
+        for key in ("accuracy", "device", "surrogate_model", "acq_func")
+    }
+    return normalized, normalization
+
+
+def _condition_space_size(condition_dict: dict[str, list[str]]) -> int:
+    size = 1
+    for values in condition_dict.values():
+        size *= len(values)
+    return size
+
+
 def _runtime_config() -> dict[str, Any]:
     path = SKILL_DIR / "runtime.local.json"
     if not path.is_file():
@@ -63,55 +170,6 @@ def _resolve_cli(explicit: str | None, runtime: dict[str, Any]) -> str:
     )
 
 
-def _cli_science_base_url(cli: str, env: dict[str, str], timeout: float) -> str:
-    explicit = env.get("DELTA_INFRA_SCIENCE_BASE_URL", "").strip()
-    if explicit:
-        return explicit
-    completed = subprocess.run(
-        [cli, "config", "show"],
-        capture_output=True,
-        text=True,
-        encoding="utf-8",
-        errors="replace",
-        env=env,
-        timeout=min(timeout, 15.0),
-        check=False,
-    )
-    if completed.returncode != 0:
-        return ""
-    try:
-        root = json.loads(completed.stdout)
-        value = root.get("data", {}).get("science_base_url", "")
-    except (AttributeError, json.JSONDecodeError):
-        return ""
-    return str(value).strip()
-
-
-def _catalog_profile(base_url: str, requested: str) -> str:
-    if requested != "auto":
-        return requested
-    try:
-        path = urlsplit(base_url).path.rstrip("/").lower()
-    except ValueError:
-        path = ""
-    return "legacy" if path.endswith("/science_tool") else "canonical"
-
-
-def _resolve_catalog_names(tool: str, endpoint: str, profile: str) -> tuple[str, str]:
-    if profile == "canonical":
-        return tool, endpoint
-    canonical_tool = tool.removesuffix("-service") if tool in {"antbo-service", "synbo-service"} else tool
-    resolved_tool = LEGACY_TOOL_ALIASES.get(canonical_tool, canonical_tool)
-    if endpoint.startswith(("chem_", "biology_")):
-        return resolved_tool, endpoint
-    resolved_endpoint = LEGACY_ENDPOINTS.get(canonical_tool, {}).get(endpoint)
-    if not resolved_endpoint:
-        raise ValueError(
-            f"no legacy science_tool mapping for {canonical_tool}/{endpoint}"
-        )
-    return resolved_tool, resolved_endpoint
-
-
 def _unwrap(stdout: str) -> tuple[Any, int]:
     try:
         root = json.loads(stdout)
@@ -155,6 +213,32 @@ def _unwrap(stdout: str) -> tuple[Any, int]:
     return value, depth
 
 
+def _validate_native(tool: str, endpoint: str, native: Any) -> None:
+    canonical_tool = tool.removesuffix("-service")
+    if canonical_tool == "synbo" and endpoint == "optimize":
+        if not isinstance(native, dict):
+            raise RuntimeError("SynBO optimize returned a non-object result")
+        recommendations = native.get("recommendations")
+        if not isinstance(recommendations, list) or not recommendations:
+            raise RuntimeError("SynBO optimize returned no recommendations")
+
+
+def _parse_cli_error(completed: subprocess.CompletedProcess[str]) -> tuple[str, str]:
+    detail = completed.stderr.strip() or completed.stdout.strip()
+    error_type = _CLI_ERROR_TYPES.get(completed.returncode, "cli")
+    try:
+        envelope = json.loads(detail)
+        error = envelope.get("error", {}) if isinstance(envelope, dict) else {}
+        if isinstance(error, dict):
+            error_type = str(error.get("type") or error_type)
+            message = error.get("message")
+            if message:
+                detail = str(message)
+    except (AttributeError, json.JSONDecodeError):
+        pass
+    return error_type, detail
+
+
 def _parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("--tool", required=True)
@@ -164,11 +248,6 @@ def _parser() -> argparse.ArgumentParser:
     body.add_argument("--params-json")
     parser.add_argument("--cli")
     parser.add_argument("--science-base-url")
-    parser.add_argument(
-        "--catalog-profile",
-        choices=("auto", "canonical", "legacy"),
-        default="auto",
-    )
     parser.add_argument("--timeout", type=float, default=120.0)
     return parser
 
@@ -177,12 +256,15 @@ def main() -> int:
     args = _parser().parse_args()
     started = time.perf_counter()
     stage = "arguments"
-    profile = "unknown"
-    resolved_tool = args.tool
-    resolved_endpoint = args.endpoint
+    cli_exit_code: int | None = None
+    error_type = "unknown"
+    normalization: dict[str, Any] | None = None
     try:
         data = _json_object(args.data_json, "--data-json")
         params = _json_object(args.params_json, "--params-json")
+        data, normalization = _normalize_synbo_payload(
+            args.tool, args.endpoint, data
+        )
         runtime = _runtime_config()
         stage = "cli-resolution"
         cli = _resolve_cli(args.cli, runtime)
@@ -191,19 +273,11 @@ def main() -> int:
         base_url = args.science_base_url or runtime.get("science_base_url")
         if base_url:
             env["DELTA_INFRA_SCIENCE_BASE_URL"] = str(base_url)
-        configured_base_url = _cli_science_base_url(cli, env, args.timeout)
-        requested_profile = str(runtime.get("catalog_profile", args.catalog_profile))
-        if requested_profile not in {"auto", "canonical", "legacy"}:
-            raise ValueError("catalog_profile must be auto, canonical, or legacy")
-        profile = _catalog_profile(configured_base_url, requested_profile)
-        resolved_tool, resolved_endpoint = _resolve_catalog_names(
-            args.tool, args.endpoint, profile
-        )
 
         command = [
             cli, "science", "invoke",
-            "--tool", resolved_tool,
-            "--endpoint", resolved_endpoint,
+            "--tool", args.tool,
+            "--endpoint", args.endpoint,
         ]
         if data is not None:
             command.extend(["--data", json.dumps(data, ensure_ascii=False, separators=(",", ":"))])
@@ -222,37 +296,46 @@ def main() -> int:
             check=False,
         )
         if completed.returncode != 0:
-            detail = completed.stderr.strip() or completed.stdout.strip()
+            cli_exit_code = completed.returncode
+            error_type, detail = _parse_cli_error(completed)
             raise RuntimeError(f"exit_code={completed.returncode}: {detail}")
         stage = "response-validation"
         native, depth = _unwrap(completed.stdout)
+        _validate_native(args.tool, args.endpoint, native)
         result = {
             "ok": True,
             "transport": "delta-cli",
             "tool": args.tool,
             "endpoint": args.endpoint,
-            "resolved_tool": resolved_tool,
-            "resolved_endpoint": resolved_endpoint,
-            "catalog_profile": profile,
             "elapsed_seconds": round(time.perf_counter() - started, 3),
             "envelope_depth": depth,
             "native": native,
         }
+        if normalization is not None:
+            result["request_normalization"] = normalization
         print(json.dumps(result, ensure_ascii=False))
         return 0
     except subprocess.TimeoutExpired:
+        error_type = "timeout"
         error = f"timeout after {args.timeout}s"
-    except (OSError, ValueError, RuntimeError) as exc:
+    except ValueError as exc:
+        error_type = "validation"
+        error = str(exc)
+    except OSError as exc:
+        error_type = "cli_resolution"
+        error = str(exc)
+    except RuntimeError as exc:
+        if error_type == "unknown":
+            error_type = "response_validation"
         error = str(exc)
     print(json.dumps({
         "ok": False,
         "transport": "delta-cli",
         "tool": args.tool,
         "endpoint": args.endpoint,
-        "resolved_tool": resolved_tool,
-        "resolved_endpoint": resolved_endpoint,
-        "catalog_profile": profile,
         "stage": stage,
+        "error_type": error_type,
+        "cli_exit_code": cli_exit_code,
         "elapsed_seconds": round(time.perf_counter() - started, 3),
         "error": error[:2000],
     }, ensure_ascii=False))

package/skills/manifest.json

@@ -2,7 +2,9 @@
   "skills": [
     "delta-sandbox",
     "delta-shared",
-    "delta-science",
+    "delta-science"
+  ],
+  "retired_skills": [
     "pubchem",
     "rdkit",
     "pymatgen",