@delta-infra/cli 1.0.96 → 1.0.98

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

@@ -0,0 +1,69 @@
+"""Generated Science catalog aliases. Do not edit by hand."""
+
+LEGACY_TOOL_ALIASES = {
+    "synbo": "synbo-service",
+    "antbo": "antbo-service",
+}
+
+LEGACY_ENDPOINTS = {
+    "pubchem": {
+        "health": "chem_pubchem_health",
+        "compound-resolve-cids": "chem_pubchem_compound_resolve-cids",
+        "compound-properties": "chem_pubchem_compound_properties",
+        "compound-synonyms": "chem_pubchem_compound_synonyms",
+        "compound-summary": "chem_pubchem_compound_summary",
+        "compound-batch-summary": "chem_pubchem_compound_batch-summary",
+    },
+    "rdkit": {
+        "health": "chem_rdkit_health",
+        "parse": "chem_rdkit_parse",
+        "descriptors": "chem_rdkit_descriptors",
+        "batch-descriptors": "chem_rdkit_batch-descriptors",
+        "batch-parse-describe": "chem_rdkit_batch-parse-describe",
+        "render": "chem_rdkit_render",
+        "fingerprint": "chem_rdkit_fingerprint",
+        "similarity": "chem_rdkit_similarity",
+        "similarity-matrix": "chem_rdkit_similarity-matrix",
+        "substructure": "chem_rdkit_substructure",
+    },
+    "pymatgen": {
+        "health": "chem_pymatgen_health",
+        "composition-parse": "chem_pymatgen_composition_parse",
+        "structure-parse": "chem_pymatgen_structure_parse",
+        "structure-summary": "chem_pymatgen_structure_summary",
+        "structure-convert": "chem_pymatgen_structure_convert",
+        "structure-symmetry": "chem_pymatgen_structure_symmetry",
+    },
+    "gsasii": {
+        "health": "chem_gsasii_health",
+        "powder-simulate": "chem_gsasii_powder_simulate",
+        "powder-refine": "chem_gsasii_powder_refine",
+    },
+    "lammps": {
+        "health": "chem_lammps_health",
+        "lj-melt-example": "chem_lammps_examples_lj-melt",
+        "run": "chem_lammps_run",
+    },
+    "delta-bo": {
+        "commands": "chem_delta-bo_commands",
+        "generate": "chem_delta-bo_generate",
+    },
+    "ldm-bo": {
+        "health": "chem_ldm-bo_health",
+        "recommend": "chem_ldm-bo_recommend",
+        "trajectory": "chem_ldm-bo_trajectory",
+    },
+    "synbo": {
+        "health": "chem_synbo_health",
+        "initialize": "chem_synbo_initialize",
+        "optimize": "chem_synbo_optimize",
+    },
+    "antbo": {
+        "health": "biology_antbo_health",
+        "run-default-job": "biology_antbo_run_default_job",
+        "run": "biology_antbo_run",
+        "log": "biology_antbo_log",
+        "jobs": "biology_antbo_jobs",
+        "stop": "biology_antbo_stop",
+    },
+}

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

@@ -0,0 +1,346 @@
+#!/usr/bin/env python3
+"""Invoke one Delta Science operation strictly through delta-cli."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import time
+from typing import Any
+
+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:
+    if raw is None:
+        return None
+    try:
+        value = json.loads(raw)
+    except json.JSONDecodeError as exc:
+        raise ValueError(f"{flag} is not valid JSON: {exc}") from exc
+    if not isinstance(value, dict):
+        raise ValueError(f"{flag} must decode to a JSON object")
+    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():
+        return {}
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}
+    return value if isinstance(value, dict) else {}
+
+
+def _resolve_cli(explicit: str | None, runtime: dict[str, Any]) -> str:
+    candidates: list[str | None] = [
+        explicit,
+        os.environ.get("DELTA_CLI_PATH"),
+        runtime.get("cli_path"),
+        shutil.which("delta-cli"),
+        shutil.which("delta-cli.exe"),
+    ]
+    package_root = SKILL_DIR.parents[1]
+    exe_name = "delta-cli.exe" if os.name == "nt" else "delta-cli"
+    candidates.append(str(package_root / "bin" / exe_name))
+    for candidate in candidates:
+        if candidate and Path(candidate).is_file():
+            return str(Path(candidate).resolve())
+    raise FileNotFoundError(
+        "delta-cli not found; install @delta-infra/cli, set DELTA_CLI_PATH, "
+        "or add cli_path to delta-science/runtime.local.json"
+    )
+
+
+def _unwrap(stdout: str) -> tuple[Any, int]:
+    try:
+        root = json.loads(stdout)
+    except json.JSONDecodeError as exc:
+        raise RuntimeError(f"CLI stdout is not JSON: {exc}") from exc
+    if not isinstance(root, dict):
+        raise RuntimeError("CLI stdout root is not an object")
+    if root.get("ok") is not True:
+        raise RuntimeError(json.dumps(root.get("error", root), ensure_ascii=False))
+    if "data" not in root:
+        raise RuntimeError("CLI success envelope is missing data")
+
+    value: Any = root["data"]
+    depth = 0
+    while isinstance(value, dict):
+        if "status_code" in value and "data" in value:
+            status_code = value.get("status_code")
+            if not isinstance(status_code, int) or not 200 <= status_code < 300:
+                raise RuntimeError(json.dumps(value, ensure_ascii=False))
+            value = value["data"]
+        elif (
+            "code" in value
+            and "data" in value
+            and set(value).intersection({"message", "msg"})
+        ):
+            code = value.get("code")
+            if code not in (0, "0", None):
+                raise RuntimeError(json.dumps(value, ensure_ascii=False))
+            value = value["data"]
+        else:
+            break
+        depth += 1
+        if depth > 4:
+            raise RuntimeError("too many nested service envelopes")
+    if isinstance(value, dict) and value.get("valid") is False:
+        raise RuntimeError(json.dumps({
+            "valid": False,
+            "error": value.get("error"),
+            "warnings": value.get("warnings"),
+        }, ensure_ascii=False))
+    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)
+    parser.add_argument("--endpoint", required=True)
+    body = parser.add_mutually_exclusive_group()
+    body.add_argument("--data-json")
+    body.add_argument("--params-json")
+    parser.add_argument("--cli")
+    parser.add_argument("--science-base-url")
+    parser.add_argument("--timeout", type=float, default=120.0)
+    return parser
+
+
+def main() -> int:
+    args = _parser().parse_args()
+    started = time.perf_counter()
+    stage = "arguments"
+    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)
+
+        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", "invoke",
+            "--tool", args.tool,
+            "--endpoint", args.endpoint,
+        ]
+        if data is not None:
+            command.extend(["--data", json.dumps(data, ensure_ascii=False, separators=(",", ":"))])
+        if params is not None:
+            command.extend(["--params", json.dumps(params, ensure_ascii=False, separators=(",", ":"))])
+
+        stage = "delta-cli"
+        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:
+            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,
+            "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 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,
+        "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))
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/delta-shared/SKILL.md

@@ -1,97 +1,97 @@
----
-name: delta-shared
-description: "delta-cli 全局共享规则：配置/认证检查、安全红线、错误处理、sandbox 销毁。"
----
-
-# delta-cli 共享规则
-
-指导 AI 使用 `delta-cli` 的通用规则。核心原则：**只检查、不猜测、不泄露密钥**。
-
-## 执行任何操作之前
-
-1. 确认服务端地址：
-   ```bash
-   delta-cli config show
-   ```
-2. 确认认证状态：
-   ```bash
-   delta-cli auth status
-   ```
-
-- 若 `auth status` 显示 `method: token`，**直接执行目标命令**，不要重复登录或初始化配置。
-- 若显示 `method: none`，或操作返回 `error.type: auth` / `permission`，才进入下面的“补全配置”流程。
-
-## 补全配置
-
-缺少服务端地址或凭证时，**向用户询问一次**，然后用 flag 初始化：
-
-```bash
-delta-cli config init --base-url <server-url> --token <token>
-```
-
-不要用交互式 `config init`（无 flag），避免在 stdin 不可用时卡住。
-
-### 信息来源优先级
-
-1. 环境变量：`DELTA_INFRA_BASE_URL`、`DELTA_INFRA_TOKEN`
-2. `~/.delta-infra/config.json` 中的 `base_url` / `token`
-3. 默认值：仅 `base_url` 有内部默认值
-4. 以上都缺失时，**必须询问用户**，禁止虚构
-
-### 运行时凭证
-
-CLI 使用 `token` 发送请求头 `Authorization: Bearer <token>`，并自动从 JWT 中提取 `uid` 作为 `X-User-Uid`。
-
-## 安全红线
-
-- **禁止输出密钥**：`token` 不得出现在日志、消息、终端。
-- **禁止自己拼 URL / 构造 HTTP 请求**：所有请求都走 `delta-cli`。
-- **不要主动安装 CLI**：如果用户说没装，建议他去 README 或 install.sh，不要自己选安装方式。
-- **写入/删除操作前确认意图**：`sandbox kill`、`sandbox finish`、`sandbox write` 等必须告诉用户影响。
-- `~/.delta-infra/config.json` 权限为 `0600`，不要手动放宽。
-- **sandbox 必须销毁**：调用 `sandbox create` 后，当前任务结束前必须调用 `sandbox kill`。server 端无自动清理，不销毁 = 永久占用 GPU；即使出错也不得跳过。
-
-## JSON 输出约定
-
-```json
-{"ok":true,"data":{...}}
-{"ok":false,"error":{"type":"auth","message":"...","hint":"..."}}
-```
-
-AI Agent 解析规则：
-- 始终检查 `ok`，不要只看 exit code。
-- `error.type` 是稳定分支字段：`auth`, `permission`, `not_found`, `validation`, `network`, `api`, `command_failed`, `internal`。
-- `error.hint` 可展示给用户。
-
-## 退出码约定
-
-| Type | Exit Code | 场景 |
-|------|-----------|------|
-| validation | 2 | flag / 参数错误 |
-| auth | 3 | 未认证或认证失败 |
-| permission | 4 | 权限不足 |
-| not_found | 5 | sandbox/file 不存在 |
-| network | 6 | DNS、超时、连接失败 |
-| api | 7 | 服务端非 2xx |
-| command_failed | 8 | sandbox 内命令执行失败（非零 exit_code 或报错）；SSE 路径在 complete 帧后追加该 error 信封，**message 附 stderr 尾部**便于快速扫读 |
-| internal | 10 | 客户端内部错误 |
-
-## 升级检查
-
-完成用户请求后，如果 JSON 中有 `_notice.update`，可建议：
-
-```bash
-delta-cli upgrade
-```
-
-## 常见恢复
-
-| 错误 / 现象 | 恢复动作 |
-|-------------|----------|
-| `error.type: auth` / `method: none` | 询问用户后执行 `config init --base-url <url> --token <token>` |
-| `error.type: permission` | 确认当前认证是否有权限；必要时换 token |
-| `error.type: not_found` | 检查 `sandbox_id` / path |
-| `error.type: network` | 检查 `base_url` 和网络连通性 |
-| `error.type: validation` | 检查必填 flag 和参数格式 |
-| `error.type: command_failed` | sandbox 内命令失败：信封 `message` 已带 stderr 尾部，可快速定位；完整 `stderr`/`result_summary` 在 complete 帧里，重试或修正命令 |
-| 配置文件解析失败 | 检查 `~/.delta-infra/config.json` 是否为有效 JSON |
+---
+name: delta-shared
+description: "delta-cli 全局共享规则：配置/认证检查、安全红线、错误处理、sandbox 销毁。"
+---
+
+# delta-cli 共享规则
+
+指导 AI 使用 `delta-cli` 的通用规则。核心原则：**只检查、不猜测、不泄露密钥**。
+
+## 执行任何操作之前
+
+1. 确认服务端地址：
+   ```bash
+   delta-cli config show
+   ```
+2. 确认认证状态：
+   ```bash
+   delta-cli auth status
+   ```
+
+- 若 `auth status` 显示 `method: token`，**直接执行目标命令**，不要重复登录或初始化配置。
+- 若显示 `method: none`，或操作返回 `error.type: auth` / `permission`，才进入下面的“补全配置”流程。
+
+## 补全配置
+
+缺少服务端地址或凭证时，**向用户询问一次**，然后用 flag 初始化：
+
+```bash
+delta-cli config init --base-url <server-url> --token <token>
+```
+
+不要用交互式 `config init`（无 flag），避免在 stdin 不可用时卡住。
+
+### 信息来源优先级
+
+1. 环境变量：`DELTA_INFRA_BASE_URL`、`DELTA_INFRA_TOKEN`
+2. `~/.delta-infra/config.json` 中的 `base_url` / `token`
+3. 默认值：仅 `base_url` 有内部默认值
+4. 以上都缺失时，**必须询问用户**，禁止虚构
+
+### 运行时凭证
+
+CLI 使用 `token` 发送请求头 `Authorization: Bearer <token>`，并自动从 JWT 中提取 `uid` 作为 `X-User-Uid`。
+
+## 安全红线
+
+- **禁止输出密钥**：`token` 不得出现在日志、消息、终端。
+- **禁止自己拼 URL / 构造 HTTP 请求**：所有请求都走 `delta-cli`。
+- **不要主动安装 CLI**：如果用户说没装，建议他去 README 或 install.sh，不要自己选安装方式。
+- **写入/删除操作前确认意图**：`sandbox kill`、`sandbox finish`、`sandbox write` 等必须告诉用户影响。
+- `~/.delta-infra/config.json` 权限为 `0600`，不要手动放宽。
+- **sandbox 必须销毁**：调用 `sandbox create` 后，当前任务结束前必须调用 `sandbox kill`。server 端无自动清理，不销毁 = 永久占用 GPU；即使出错也不得跳过。
+
+## JSON 输出约定
+
+```json
+{"ok":true,"data":{...}}
+{"ok":false,"error":{"type":"auth","message":"...","hint":"..."}}
+```
+
+AI Agent 解析规则：
+- 始终检查 `ok`，不要只看 exit code。
+- `error.type` 是稳定分支字段：`auth`, `permission`, `not_found`, `validation`, `network`, `api`, `command_failed`, `internal`。
+- `error.hint` 可展示给用户。
+
+## 退出码约定
+
+| Type | Exit Code | 场景 |
+|------|-----------|------|
+| validation | 2 | flag / 参数错误 |
+| auth | 3 | 未认证或认证失败 |
+| permission | 4 | 权限不足 |
+| not_found | 5 | sandbox/file 不存在 |
+| network | 6 | DNS、超时、连接失败 |
+| api | 7 | 服务端非 2xx |
+| command_failed | 8 | sandbox 内命令执行失败（非零 exit_code 或报错）；SSE 路径在 complete 帧后追加该 error 信封，**message 附 stderr 尾部**便于快速扫读 |
+| internal | 10 | 客户端内部错误 |
+
+## 升级检查
+
+完成用户请求后，如果 JSON 中有 `_notice.update`，可建议：
+
+```bash
+delta-cli upgrade
+```
+
+## 常见恢复
+
+| 错误 / 现象 | 恢复动作 |
+|-------------|----------|
+| `error.type: auth` / `method: none` | 询问用户后执行 `config init --base-url <url> --token <token>` |
+| `error.type: permission` | 确认当前认证是否有权限；必要时换 token |
+| `error.type: not_found` | 检查 `sandbox_id` / path |
+| `error.type: network` | 检查 `base_url` 和网络连通性 |
+| `error.type: validation` | 检查必填 flag 和参数格式 |
+| `error.type: command_failed` | sandbox 内命令失败：信封 `message` 已带 stderr 尾部，可快速定位；完整 `stderr`/`result_summary` 在 complete 帧里，重试或修正命令 |
+| 配置文件解析失败 | 检查 `~/.delta-infra/config.json` 是否为有效 JSON |

package/skills/delta-shared/agents/openai.yaml

@@ -1,4 +1,4 @@
-interface:
-  display_name: "Delta CLI 共享规则"
-  short_description: "处理 Delta CLI 的配置、认证、错误与安全边界"
-  default_prompt: "使用 $delta-shared 检查并处理 Delta CLI 的配置或认证问题。"
+interface:
+  display_name: "Delta CLI 共享规则"
+  short_description: "处理 Delta CLI 的配置、认证、错误与安全边界"
+  default_prompt: "使用 $delta-shared 检查并处理 Delta CLI 的配置或认证问题。"

package/skills/manifest.json

@@ -1,19 +1,19 @@
-{
-  "skills": [
-    "delta-sandbox",
-    "delta-shared",
-    "delta-science"
-  ],
-  "retired_skills": [
-    "pubchem",
-    "rdkit",
-    "pymatgen",
-    "gsasii",
-    "lammps",
-    "delta-bo",
-    "ldm-bo",
-    "synbo-service",
-    "antbo-service",
-    "antbo-ldm-guard"
-  ]
-}
+{
+  "skills": [
+    "delta-sandbox",
+    "delta-shared",
+    "delta-science"
+  ],
+  "retired_skills": [
+    "pubchem",
+    "rdkit",
+    "pymatgen",
+    "gsasii",
+    "lammps",
+    "delta-bo",
+    "ldm-bo",
+    "synbo-service",
+    "antbo-service",
+    "antbo-ldm-guard"
+  ]
+}