dsh-scnet 0.1.0 → 0.2.1

package/README.md

@@ -1,26 +1,20 @@
 <h1 align="center">dsh-scnet</h1>
 
-<p align="center">在 DeepSeek Harness 里操作超算互联网（scnet.cn）及同类国产超算集群：配 SSH、生成 Slurm 作业、探测集群、排查失败，附海光 DCU/DTK 知识。</p>
+<p align="center">在 DeepSeek Harness 里操作超算互联网（scnet.cn）及同类国产超算集群：配 SSH、生成 Slurm 作业、探测/刷新集群、运行计算节点探针、排查失败，附海光 DCU/DTK 知识。</p>
 
 ## 这是什么
 
-一个 DeepSeek Harness 官方 bundle 插件，把 `scnet-hpc` 的 Agent Skill 和 bash 脚本包装成 DSH 可安装包。装好后 DSH 模型在涉及超算集群、Slurm 作业、海光 DCU/DTK 时会加载对应 skill，并可调用工具完成确定性操作。
+一个 DeepSeek Harness bundle 插件，把 `scnet-hpc` 的 Agent Skill 和 bash 脚本包装成 DSH 可安装包。装好后 DSH 模型在涉及超算集群、Slurm 作业、海光 DCU/DTK 时会加载对应 skill，并可调用工具完成确定性操作。
 
 ## 安装
 
-```sh
-dsh plugin --profile web add "github:lql341/dsh-scnet#main"
-```
-
-或本地目录：
+推荐从 npm 安装：
 
 ```sh
-git clone https://github.com/lql341/dsh-scnet.git
-cd dsh-scnet
-dsh plugin --profile web add .
+dsh plugin --profile web add dsh-scnet
 ```
 
-> git 源安装会取源码而非构建产物；本插件入口是纯 JavaScript（无编译步骤），无需 allowBuilds。
+git 源、本地目录安装以及验证步骤见 [INSTALL.md](./INSTALL.md)。
 
 ## 能力面
 
@@ -30,6 +24,14 @@ dsh plugin --profile web add .
 |---|---|
 | scnet-hpc | 国产超算使用规范：连接、提交/监控、调试、失败排查、海光 DCU/DTK 资源索引 |
 
+### 内置集群
+
+| 短名 | 描述 | 加速器 |
+|---|---|---|
+| zzeshell | 超算互联网 · 郑州 | 海光 BW1000 DCU (gfx936) ×8, 64GB/卡 |
+| kseshell | 超算互联网 · 昆山 | 海光 Z100 DCU (gfx906) ×4, 16GB/卡 |
+| wuzhshell | 超算互联网 · 乌镇 | 海光 Z100 DCU (gfx906) ×4, 16GB/卡 |
+
 ### Tools
 
 | 工具 | 说明 |
@@ -39,6 +41,13 @@ dsh plugin --profile web add .
 | scnet_generate_job | 按 profile 生成合规 Slurm 作业脚本 |
 | scnet_setup_ssh | 配置本地到集群的 SSH 连接 |
 | scnet_probe_cluster | 探测新集群并生成 profile |
+| scnet_refresh_cluster | 动态刷新已有集群的规则缓存 |
+| scnet_run_compute_probe | 在计算节点运行最小能力探针 |
+
+## 文档
+
+- [INSTALL.md](./INSTALL.md) — 安装与验证
+- [TESTING.md](./TESTING.md) — 按风险排序的初步测试步骤
 
 ## 结构
 
@@ -46,10 +55,20 @@ dsh plugin --profile web add .
 .
 ├── package.json          # dsh.bundle + dsh.skills
 ├── cordis.patch.yml      # bundle 组合层
-├── index.mjs             # Cordis 入口，注册 5 个工具
-├── skills/scnet-hpc/     # Agent Skill + clusters/scripts/references
+├── index.mjs             # Cordis 入口，注册 7 个工具
+├── skills/scnet-hpc/
+│   ├── clusters/
+│   │   ├── zzeshell.conf
+│   │   ├── kseshell.conf
+│   │   └── wuzhshell.conf
+│   ├── scripts/
+│   └── references/
 ├── sync.sh               # 从 canonical 仓库同步
-└── README.md
+├── README.md             # 项目说明
+├── INSTALL.md            # 安装与验证
+├── TESTING.md            # 初步测试步骤
+├── LICENSE
+└── .gitignore
 ```
 
 ## 同步
@@ -62,13 +81,16 @@ dsh plugin --profile web add .
 ```
 
 只改 canonical，本仓库跑 sync 更新；不要把 `skills/scnet-hpc/` 当手工维护目录。
+`sync.sh` 会自动排除 `scripts/install.sh` 和 `clusters/.cache/`，避免把安装脚本或本机动态缓存打进发布包。
 
 ## 隐私与安全
 
 - 仓库不含私钥、token、用户名、密钥指纹。
 - `scnet_setup_ssh` 会写入 `~/.ssh/`，调用前确认私钥路径和集群。
 - `scnet_generate_job` 生成的 `.slurm` 可能含本机用户名，`.gitignore` 已排除。
-- 集群主机名/端口是平台公开信息；profile 中连接字段默认留空，由用户本地填写。
+- 集群主机名/端口是平台公开信息，由 canonical 仓库维护。
+- `scnet_refresh_cluster` / `scnet_run_compute_probe` 会 SSH 到远端并可能提交作业；运行前确认集群和副作用。
+- `clusters/.cache/` 是本机动态探测缓存，`.gitignore` 已排除，不应提交。
 
 ## License
 

package/index.mjs

@@ -134,6 +134,8 @@ export function apply(ctx) {
         time: { type: 'string', description: '时长，默认 00:20:00，格式 HH:MM:SS 或 D-HH:MM:SS' },
         cluster: { type: 'string', description: '集群短名；省略时若只有一个 profile 则自动选择' },
         remote_user: { type: 'string', description: '远端用户名；与本地不同时填写（日志路径需要真实用户名）' },
+        refresh: { type: 'boolean', description: '是否在生成前运行 refresh-cluster.sh 刷新动态规则（默认否）' },
+        no_auto: { type: 'boolean', description: '是否忽略 clusters/.cache/*.auto.conf 动态缓存（默认否）' },
       },
       output: {
         schema: { type: 'string' },
@@ -153,18 +155,51 @@ export function apply(ctx) {
         if (cluster) argv.push('--cluster', cluster)
         const remoteUser = String(args.remote_user || '').trim()
         if (remoteUser) argv.push('--user', remoteUser)
+        if (args.refresh === true) argv.push('--refresh')
+        if (args.no_auto === true) argv.push('--no-auto')
         argv.push(nameVal)
         if (accelerators) argv.push(accelerators.value)
         if (cpus) argv.push(cpus.value)
         if (args.time && String(args.time).trim()) argv.push(String(args.time).trim())
 
-        const res = await runBash(join(SCRIPTS_DIR, 'new-job.sh'), argv, 30000)
+        const timeoutMs = args.refresh === true ? 240000 : 30000
+        const res = await runBash(join(SCRIPTS_DIR, 'new-job.sh'), argv, timeoutMs)
         if (res.ok) return res.stdout.trim() || res.stderr.trim()
         return `生成失败（exit ${res.code}）：\n${res.stderr.trim() || res.stdout.trim()}`
       },
     }),
   )
 
+  ctx.tools.register(
+    defineTool({
+      name: 'scnet_refresh_cluster',
+      description:
+        '动态刷新指定集群的规则缓存（分区、内存、GRES、网络、登录节点缺库等）。默认只做登录节点只读探测；compute=true 会额外提交一个约 10 分钟的计算节点能力探针，会 SSH 到远端并写 clusters/.cache/<短名>.auto.conf。',
+      parameters: {
+        cluster: { type: 'string', description: '集群短名；省略时若只有一个 profile 则自动选择' },
+        compute: { type: 'boolean', description: '是否额外提交计算节点能力探针（默认否）' },
+        dry_run: { type: 'boolean', description: '只输出将要写入的缓存，不落盘（默认否）' },
+      },
+      timeoutMs: 900000,
+      output: {
+        schema: { type: 'string' },
+        render: (_args, value) => textBlock(value),
+      },
+      async execute(args) {
+        const argv = []
+        const cluster = String(args.cluster || '').trim()
+        if (cluster) argv.push('--cluster', cluster)
+        if (args.compute === true) argv.push('--compute')
+        if (args.dry_run === true) argv.push('--dry-run')
+
+        const timeoutMs = args.compute === true ? 900000 : 240000
+        const res = await runBash(join(SCRIPTS_DIR, 'refresh-cluster.sh'), argv, timeoutMs)
+        if (res.ok) return res.stdout.trim() || res.stderr.trim()
+        return `刷新失败（exit ${res.code}）：\n${res.stderr.trim() || res.stdout.trim()}`
+      },
+    }),
+  )
+
   ctx.tools.register(
     defineTool({
       name: 'scnet_setup_ssh',
@@ -194,6 +229,46 @@ export function apply(ctx) {
     }),
   )
 
+  ctx.tools.register(
+    defineTool({
+      name: 'scnet_run_compute_probe',
+      description:
+        '在已配置 SSH 的集群计算节点上运行最小能力探针，输出 PROBE_ 开头的结果（加速器架构、FP8、Triton、bitsandbytes、外网等）。会提交一个 1 卡、4 核、10 分钟的小作业并等待完成。',
+      parameters: {
+        cluster: { type: 'string', required: true, description: '集群短名' },
+        accelerators: { type: 'string', description: '加速器数量，默认 1' },
+        cpus: { type: 'string', description: 'CPU 核数，默认 4' },
+        time: { type: 'string', description: '作业时长，默认 00:10:00' },
+        remote_user: { type: 'string', description: '远端用户名；与本地不同时填写' },
+      },
+      timeoutMs: 900000,
+      output: {
+        schema: { type: 'string' },
+        render: (_args, value) => textBlock(value),
+      },
+      async execute(args) {
+        const cluster = String(args.cluster || '').trim()
+        if (!cluster) return '缺少必填参数 cluster。'
+
+        const accelerators = positiveInt(args.accelerators, 'accelerators')
+        if (accelerators && accelerators.error) return accelerators.error
+        const cpus = positiveInt(args.cpus, 'cpus')
+        if (cpus && cpus.error) return cpus.error
+
+        const argv = ['--cluster', cluster]
+        const remoteUser = String(args.remote_user || '').trim()
+        if (remoteUser) argv.push('--user', remoteUser)
+        if (cpus) argv.push('--cpus', cpus.value)
+        if (args.time && String(args.time).trim()) argv.push('--time', String(args.time).trim())
+        if (accelerators) argv.push('--accelerators', accelerators.value)
+
+        const res = await runBash(join(SCRIPTS_DIR, 'run-compute-probe.sh'), argv, 900000)
+        if (res.ok) return res.stdout.trim()
+        return `计算节点探针失败（exit ${res.code}）：\n${res.stderr.trim() || res.stdout.trim()}`
+      },
+    }),
+  )
+
   ctx.tools.register(
     defineTool({
       name: 'scnet_probe_cluster',

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-scnet",
-  "version": "0.1.0",
-  "description": "DeepSeek Harness bundle plugin for SCNet (scnet.cn) and similar domestic HPC clusters: SSH setup, Slurm job generation, cluster probing, and Hygon DCU/DTK guidance.",
+  "version": "0.2.1",
+  "description": "DeepSeek Harness bundle plugin for SCNet (scnet.cn) and similar domestic HPC clusters: SSH setup, Slurm job generation, cluster probing/refresh, compute-node capability probes, and Hygon DCU/DTK guidance.",
   "type": "module",
   "main": "./index.mjs",
   "exports": {
@@ -9,6 +9,13 @@
     "./cordis.patch.yml": "./cordis.patch.yml",
     "./package.json": "./package.json"
   },
+  "dependencies": {
+    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lql341/dsh-scnet.git"
+  },
   "files": [
     "index.mjs",
     "cordis.patch.yml",
@@ -23,7 +30,7 @@
     ]
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=22.19"
   },
   "keywords": [
     "deepseek-harness",

package/skills/scnet-hpc/SKILL.md

@@ -24,6 +24,8 @@ cat clusters/<集群短名>.conf     # 看具体参数
 | `clusters/_template.conf` | 新增集群的模板 |
 | `scripts/setup-ssh.sh` | 新电脑上配连接（macOS/Linux，幂等）|
 | `scripts/probe-cluster.sh` | 探测新集群，自动生成 profile |
+| `scripts/refresh-cluster.sh` | 动态刷新已有集群的规则缓存 |
+| `scripts/run-compute-probe.sh` | 在计算节点运行最小能力探针 |
 | `scripts/new-job.sh` | 按 profile 生成合规的作业脚本 |
 | `references/setup.md` | 连接配置详解、平台差异、故障排查 |
 | `references/environment.md` | 环境栈、装依赖、目录约定、迁移注意 |
@@ -34,12 +36,14 @@ cat clusters/<集群短名>.conf     # 看具体参数
 
 ## 换机器
 
-本插件已随 DeepSeek Harness 安装，换机器时用 `dsh plugin --profile web add` 重装即可。
+本插件已随 DeepSeek Harness 安装，换机器时用 `dsh plugin --profile web add dsh-scnet` 重装即可。
 配置集群连接：
 
 ```bash
-./scripts/setup-ssh.sh <私钥文件>              # 配连接（自动读唯一的 profile）
+./scripts/setup-ssh.sh --cluster <集群短名> <私钥文件> <用户名>
 ```
+
+只有一个 profile 时可省略 `--cluster`；公开 profile 里的 `KEY_NAME_MARKER` 是占位符，所以需要显式传用户名。
 ## 新增集群
 
 ```bash
@@ -51,6 +55,30 @@ cat clusters/<集群短名>.conf     # 看具体参数
 
 完整步骤见 `references/adding-cluster.md`。
 
+## 动态刷新已有集群规则
+
+profile 里的 `SSH_HOST` / `SSH_PORT` 是固定连接参数，应写死在
+`clusters/<集群短名>.conf`。其余容易随平台调整的规则
+（`DEF_MEM_PER_CPU`、`MIN_GRES`、`PARTITION`、`NET_OK`、登录节点缺库等）
+可以动态探测：
+
+```bash
+./scripts/refresh-cluster.sh --cluster <集群短名>          # 只做登录节点只读探测
+./scripts/refresh-cluster.sh --cluster <集群短名> --compute # 再提交一个 10 分钟小作业
+./scripts/refresh-cluster.sh --cluster <集群短名> --dry-run  # 只看结果，不写缓存
+```
+
+结果写到 `clusters/.cache/<集群短名>.auto.conf`，后续脚本会自动加载并覆盖
+profile 中的同名字段。删除该缓存文件即可回退到纯 profile。生成作业时可用
+`./scripts/new-job.sh --refresh ...` 先刷新再生成，或用 `--no-auto` 忽略缓存。
+
+默认只做登录节点探测，不提交作业；`--compute` 才会到计算节点实测加速器架构、
+FP8、Triton、bitsandbytes 和外网状态。
+
+分区节点数 `NODE_COUNT` 是例外：每次加载集群时都会实时查询当前
+`PARTITION` 的 `TotalNodes`，查不到才回退到 cache/profile。需要关闭时设
+`SCNET_HPC_LIVE_NODE_COUNT=no`。
+
 ## 通用硬约束
 
 以下几条在国产超算上普遍存在，**具体数值查 profile**。
@@ -222,6 +250,8 @@ Triton 那条影响最大：**任何依赖 Triton kernel 的推理框架都跑
 | `lib*.so: cannot open shared object file` | 没 `module load`，或在登录节点跑了 |
 | `Name or service not known` / `offline mode` | 计算节点在访问外网 |
 | `hipDrvLaunchKernelEx` | Triton 不可用，换纯 PyTorch 路线 |
+| `libgcvm.so.17git: cannot open shared object file` | Triton 在当前 DTK/DCU 栈不可用 |
+| `python3: command not found` | 昆山计算节点需 `module load python/3.8.10` |
 | `sacct` COMPLETED 但结果不对 | 脚本缺 `exit $rc` |
 
 完整手册见 `references/troubleshooting.md`。

package/skills/scnet-hpc/clusters/_template.conf

@@ -3,10 +3,11 @@
 # 新增集群：
 #   1. cp _template.conf <集群短名>.conf
 #   2. 填下面的值（不确定的用 scripts/probe-cluster.sh 探测）
-#   3. scripts/setup-ssh.sh --cluster <集群短名> <私钥文件>
+#   3. scripts/setup-ssh.sh --cluster <集群短名> <私钥文件> [用户名]
 #
-# 只有 CLUSTER_ID / SSH_HOST / SSH_PORT 是必填，其余可留空，
-# 留空的项脚本会跳过、文档里显示为「未探测」。
+# CLUSTER_ID / SSH_HOST / SSH_PORT 是必填连接参数，应写死；其余可留空。
+# 留空的项脚本会跳过、文档里显示为「未探测」。旧 profile 漏填 SSH_HOST 时，
+# _common.sh 会临时从本机 ssh config 补全，但新集群仍建议在此显式填写。
 
 # ---- 连接（必填）----
 CLUSTER_ID=""                            # 短名，同时用作 ssh 别名，如 "zzeshell"
@@ -35,7 +36,7 @@ ACCEL_MEM_GB=""
 CPUS_PER_NODE=""
 CPU_MODEL=""
 NODE_MEM_GB=""
-NODE_COUNT=""
+NODE_COUNT=""                            # 通常留空/作回退；运行时优先实时查 TotalNodes
 LOGIN_NODES=""
 HOME_QUOTA_GB=""
 
@@ -44,6 +45,7 @@ TOOLCHAIN=""                             # "DTK" / "CUDA" / "ROCm" 等
 TOOLCHAIN_VERSION=""
 TOOLCHAIN_PATH=""
 MODULE_LOADS=""                          # 空格分隔的 module load 参数
+PYTHON_MODULE=""                         # 计算节点缺少 python3 时加载的 Python module
 
 DEFAULT_VENV=""                          # 相对家目录的 venv 路径
 

package/skills/scnet-hpc/clusters/kseshell.conf

@@ -1,4 +1,4 @@
-# kseshell —— 海光 Z100 DCU 集群（共享模板；连接字段需按平台填写）
+# kseshell —— 海光 Z100 DCU 集群（连接字段已按平台填写）
 #
 # SCNet 昆山集群。与郑州（zzeshell / BW1000 / gfx936）的主要差别：
 #   - 加速器是 Z100 (gfx906)，单机 4 卡、每卡 16GB（BW1000 是 8 卡 × 64GB）
@@ -9,11 +9,11 @@
 # ---- 连接 ----
 CLUSTER_ID="kseshell"
 CLUSTER_DESC="海光 Z100 DCU（昆山）"
-SSH_HOST=""
-SSH_PORT=""
+SSH_HOST="cancon.hpccube.com"
+SSH_PORT="65023"
 HOME_BASE="/public/home"
 
-KEY_NAME_MARKER=""
+KEY_NAME_MARKER="_<CLUSTER_HOST>_"
 NEEDS_UPDATE_HOSTKEYS_NO="no"            # 实测无坏签名告警
 
 # ---- 调度器 ----
@@ -46,8 +46,8 @@ ACCEL_TDP_W="300"
 CPUS_PER_NODE="32"
 CPU_MODEL="Hygon C86 7185 32-core"
 NODE_MEM_GB="123"
-NODE_COUNT="571"                         # kshdnormal；CPU 队列 3557 节点
-LOGIN_NODES="login07 等（有多台）"
+NODE_COUNT="1368"                        # 回退值；运行时优先实时查 TotalNodes
+LOGIN_NODES="login01 / login02（示意）"
 HOME_QUOTA_GB="2950"                     # /public 文件系统总量，非个人独占
 
 # ---- 软件栈 ----
@@ -57,6 +57,7 @@ TOOLCHAIN_PATH=""
 MODULE_LOADS="compiler/dtk/26.04"
 # 可用版本很多：22.10 / 23.04 / 23.10 / 24.04.x / 25.04.x / 26.04
 # 实测 26.04、25.04.4、24.04.3 都能正常识别 4 张 gfx906
+PYTHON_MODULE="python/3.8.10"            # 计算节点默认无 python3
 
 DEFAULT_VENV=""                          # 尚未建 venv；系统 python3 是 3.8.5，无 torch
 
@@ -76,6 +77,7 @@ LOGIN_NODE_MISSING_LIBS=""               # 登录节点无 torch（未装），
 #   - 单卡仅 16GB，大模型必须多卡切分或量化
 # 具体的 torch/Triton 能力待建 venv 后实测，参考 references/adding-cluster.md
 KNOWN_LIMITATIONS="gfx906 (Vega20) 无 FP8/BF16 硬件支持、无 MFMA Matrix Core；\
+无 BF16 数据类型支持；计算节点默认无 python3，需 module load python/3.8.10；\
 单卡显存仅 16GB；torch/Triton 可用性待实测；\
 CentOS 7.6 / glibc 2.17 环境优先使用 manylinux_2_17 wheel，onnxruntime 通常锁定 1.16.3；\
 MinerU 3.4.x 需 Python >=3.10，旧版 magika 兼容方案需单独验证 API；\

package/skills/scnet-hpc/clusters/wuzhshell.conf

@@ -0,0 +1,60 @@
+# wuzhshell —— 乌镇超算（wuzh02.hpccube.com）
+
+# ---- 连接 ----
+CLUSTER_ID="wuzhshell"
+CLUSTER_DESC="乌镇超算（wuzh02）"
+SSH_HOST="wuzh02.hpccube.com"
+SSH_PORT="65091"
+HOME_BASE="/work/home"
+
+KEY_NAME_MARKER="_<CLUSTER_HOST>_"
+NEEDS_UPDATE_HOSTKEYS_NO="no"
+
+# ---- 调度器 ----
+SCHEDULER="slurm"
+
+# 默认使用 DCU 队列；纯 CPU 作业改用 wzhcnormal。
+PARTITION="wzhdnormal"
+
+DEF_MEM_PER_CPU="3634"
+MIN_GRES="dcu:1"
+GRES_TYPE="dcu"
+MAX_WALLTIME="333-08:00:00"
+
+# CPU 队列和 DCU 队列。
+PARTITION_CPU="wzhcnormal"
+PARTITION_DCU="wzhdnormal"
+
+# ---- 硬件 ----
+ACCEL_NAME="海光 Z100 DCU (Z100SM)"
+ACCEL_ARCH="gfx906"
+ACCEL_PER_NODE="4"
+ACCEL_MEM_GB="16"
+CPUS_PER_NODE="32"
+CPU_MODEL="Hygon C86 7285 32-core Processor"
+NODE_MEM_GB="123"
+NODE_COUNT="434"
+LOGIN_NODES="login01 / login02（示意）"
+HOME_QUOTA_GB="2000"
+
+# ---- 软件栈 ----
+TOOLCHAIN="DTK"
+TOOLCHAIN_VERSION="26.04"
+TOOLCHAIN_PATH=""
+MODULE_LOADS="compiler/dtk/26.04"
+PYTHON_MODULE="python/3.8.10"
+
+DEFAULT_VENV=""
+
+# ---- 网络 ----
+NET_OK="pypi.org pypi.tuna.tsinghua.edu.cn modelscope.cn github.com"
+NET_BLOCKED="huggingface.co"
+PIP_INDEX="https://pypi.tuna.tsinghua.edu.cn/simple"
+COMPUTE_NODE_OFFLINE="yes"
+TMP_SHARED="no"
+
+# ---- 已知问题 ----
+LOGIN_NODE_MISSING_LIBS=""
+KNOWN_LIMITATIONS="gfx906 (Vega20) 无 FP8/BF16 硬件支持、无 MFMA Matrix Core；\
+单卡显存 16GB；计算节点默认无 torch（module load compiler/dtk/26.04 后仍无 torch，需建 venv）；\
+计算节点无外网（PROBE_NET_PYPI=OFFLINE）；DCU FP8/Triton/bitsandbytes 待装 torch 后实测"

package/skills/scnet-hpc/clusters/zzeshell.conf

@@ -1,4 +1,4 @@
-# zzeshell —— 海光 DCU 集群（共享模板；连接字段需按平台填写）
+# zzeshell —— 海光 DCU 集群（连接字段已按平台填写）
 #
 # 这是一个集群 profile。新增集群时复制本文件改值即可，
 # 脚本和文档都从这里读配置，不硬编码。
@@ -6,13 +6,13 @@
 # ---- 连接 ----
 CLUSTER_ID="zzeshell"                    # 短名，同时用作 ssh 别名
 CLUSTER_DESC="海光 BW1000 DCU（郑州）"
-SSH_HOST=""
-SSH_PORT=""
+SSH_HOST="zzeshell.scnet.cn"
+SSH_PORT="65032"
 HOME_BASE="/public/home"                 # 家目录父路径，实际家目录是 $HOME_BASE/$USER
 
 # 私钥文件名里的主机标识，用于从文件名推断用户名
 # 形如 <用户名>_<集群主机>_RsaKeyExpireTime_<日期>.txt
-KEY_NAME_MARKER=""
+KEY_NAME_MARKER="_<CLUSTER_HOST>_"
 
 # 平台对 SSH 主机密钥轮换扩展返回错误签名，需要 UpdateHostKeys no 抑制告警
 NEEDS_UPDATE_HOSTKEYS_NO="yes"
@@ -22,7 +22,7 @@ SCHEDULER="slurm"
 PARTITION="hx1hdnormal"
 
 # 每 CPU 默认内存（MB）。内存上限 = cpus-per-task × 此值
-DEF_MEM_PER_CPU="3888"
+DEF_MEM_PER_CPU="3800"                   # 2026-08-16 实测；旧值 3888
 
 # QOS 强制的最小 GRES。非空表示每个作业必须申请，纯 CPU 作业会被拒
 MIN_GRES="dcu:1"
@@ -40,8 +40,8 @@ ACCEL_MEM_GB="64"
 CPUS_PER_NODE="128"
 CPU_MODEL="Hygon C86"
 NODE_MEM_GB="498"
-NODE_COUNT="16"
-LOGIN_NODES="zz-login01 / zz-login02（有负载均衡）"
+NODE_COUNT="131"                         # 回退值；运行时优先实时查 TotalNodes
+LOGIN_NODES="login01 / login02（有负载均衡）"
 HOME_QUOTA_GB="1450"                     # /public 文件系统总量，非个人独占
 
 # ---- 软件栈 ----
@@ -49,6 +49,7 @@ TOOLCHAIN="DTK"                          # 海光的 ROCm 发行版
 TOOLCHAIN_VERSION="26.04"
 TOOLCHAIN_PATH=""
 MODULE_LOADS="compiler/gcc/9.3.0 compiler/dtk/26.04"
+PYTHON_MODULE=""                         # 计算节点可用 python3，无需额外加载
 
 # 默认 venv 路径（相对家目录）。因人而异，装完可改
 DEFAULT_VENV="softwares/bitsandbytes/venv"
@@ -63,10 +64,10 @@ TMP_SHARED="no"                          # /tmp 是否跨节点共享
 
 # ---- 已知的平台特有问题 ----
 # 登录节点缺失的库（导致无法在登录节点 import 深度学习框架）
-LOGIN_NODE_MISSING_LIBS="libmsgpackc.so.2"
+LOGIN_NODE_MISSING_LIBS="libgalaxyhip.so.5"
 
 # 加速器不支持的能力，写进文档避免重复踩坑
-KNOWN_LIMITATIONS="Triton 不可用（libamdhip64.so 缺 hipDrvLaunchKernelEx）；\
+KNOWN_LIMITATIONS="Triton 不可用（实测 libgcvm.so.17git 或 libamdhip64.so 缺 hipDrvLaunchKernelEx）；\
 FP8 无硬件计算支持（torch._scaled_mm 拒绝 gfx936）；\
 bitsandbytes 8-bit 不可用（hipBLASLt 无 gfx936 INT8 algo）；\
 纯 PyTorch 软件反量化可作为大模型推理退路，但单序列解码约 0.93–1.12 tok/s；\

package/skills/scnet-hpc/references/adding-cluster.md

@@ -45,6 +45,9 @@ EOF
 
 profile 末尾的注释列出了还需确认的。主要是：
 
+**`SSH_HOST` / `SSH_PORT`** —— 固定连接参数，应写死。本机已配置 SSH 别名时，
+可用 `ssh -G <别名>` 查出 `hostname` 和 `port` 后填进 profile。
+
 **加速器型号和架构** —— 在计算节点跑：
 
 ```bash
@@ -68,9 +71,12 @@ srun -p <分区> --gres=gpu:1 --time=00:05:00 nvidia-smi --query-gpu=name --form
 删掉第 2 步的临时段，然后：
 
 ```bash
-./scripts/setup-ssh.sh --cluster <集群短名> <私钥文件>
+./scripts/setup-ssh.sh --cluster <集群短名> <私钥文件> <用户名>
 ```
 
+公开 profile 使用占位符时，`<用户名>` 必须显式传入；如果已在本地私有 profile
+里填了真实 `KEY_NAME_MARKER`，可以省略。
+
 ### 6. 实测加速器能力，写回 profile
 
 **这一步别省。** 国产加速器的软件栈往往落后于上游，很多想当然的能力并不存在。
@@ -121,6 +127,10 @@ Triton 尤其值得测：**它不可用会连带否掉一大批推理框架**（
 vLLM 的 ROCm MoE 后端、transformers 的 finegrained-fp8）。提前知道能避免在框架
 适配上白费时间。
 
+已有集群后续不必重跑完整流程，可用
+`./scripts/refresh-cluster.sh --cluster <集群短名> --compute` 动态刷新调度器、
+内存、分区、网络和计算节点能力，结果写到 `clusters/.cache/<集群短名>.auto.conf`。
+
 ## profile 字段速查
 
 必填三项：`CLUSTER_ID`、`SSH_HOST`、`SSH_PORT`。其余留空则脚本跳过、文档显示为未探测。
@@ -133,7 +143,9 @@ vLLM 的 ROCm MoE 后端、transformers 的 finegrained-fp8）。提前知道能
 | `GRES_TYPE` | `new-job.sh` | 生成的脚本不含 `--gres` |
 | `DEF_MEM_PER_CPU` | `new-job.sh` | 生成的脚本不含 `--mem`，需手填 |
 | `MODULE_LOADS` | `new-job.sh` | 生成的脚本不含 `module load` |
+| `PYTHON_MODULE` | `run-compute-probe.sh` | 计算节点缺 python3 时可能找不到解释器 |
 | `DEFAULT_VENV` | `new-job.sh` | 生成的脚本不含 venv 激活 |
+| `NODE_COUNT` | 运行时回退 | 实时查 TotalNodes 失败时使用该值 |
 | `KEY_NAME_MARKER` | `setup-ssh.sh` | 无法从文件名推断用户名，需显式传 |
 | `NEEDS_UPDATE_HOSTKEYS_NO` | `setup-ssh.sh` | 不写 `UpdateHostKeys no` |
 | `COMPUTE_NODE_OFFLINE` | `new-job.sh` | 不设 `HF_HUB_OFFLINE` |

package/skills/scnet-hpc/references/environment.md

@@ -16,6 +16,14 @@ ssh <集群> 'sinfo -p <分区> -o "%n %c %m %G %t"'  # 每节点 CPU/内存/GRE
 ssh <集群> 'sacctmgr show qos where name=<QOS名> format=Name,MinTRES%30,MaxTRES%30 -P'
 ```
 
+也可以用 skill 自带的动态刷新，登录节点只读探测不会提交作业：
+
+```bash
+./scripts/refresh-cluster.sh --cluster <集群短名> --dry-run
+```
+
+其中分区节点数 `NODE_COUNT` 默认每次加载集群时实时查询 `TotalNodes`。
+
 节点状态含义：`idle` 空闲、`mix` 部分占用、`alloc` 全占、`drain`/`drng` 不可调度
 （维护中）。实际可用节点常少于总数。
 
@@ -56,6 +64,12 @@ source ~/<DEFAULT_VENV>/bin/activate
 ImportError: libgalaxyhip.so.5: cannot open shared object file
 ```
 
+昆山计算节点默认没有 `python3` 命令，需额外加载：
+
+```bash
+module load python/3.8.10
+```
+
 ## 厂商预编译的 wheel
 
 国产加速器的 torch 等框架需要厂商适配版，文件名带厂商标记。海光的例子：

package/skills/scnet-hpc/references/setup.md

@@ -87,7 +87,9 @@ ssh -O exit <集群>      # 手工断开（网络切换后卡住时用）
 `<用户名>_<主机>_RsaKeyExpireTime_2026-10-29_12-51-40.txt` 表示 2026-10-29 过期。
 到期前从控制台重新下载并重跑 setup 脚本。
 
-profile 里的 `KEY_NAME_MARKER` 就是用来从这种文件名里提取用户名的。
+profile 里的 `KEY_NAME_MARKER` 就是用来从这种文件名里提取用户名的；公开
+`scnet-hpc` profile 使用 `_<CLUSTER_HOST>_` 占位符，所以安装时通常需要显式传
+用户名，或在本地私有 profile 中补齐真实标记。
 
 查看当前密钥指纹：
 

package/skills/scnet-hpc/references/troubleshooting.md

@@ -54,8 +54,9 @@ sbatch: error: QOSMinGRES
 
 三种可能：
 
-1. **在登录节点跑 torch** —— 登录节点缺 `libmsgpackc.so.2`，即使 `module load`
-   之后也 import 不了。必须用 `srun`/`sbatch`。
+1. **在登录节点跑 torch** —— 郑州集群最近实测是缺 `libgalaxyhip.so.5`，旧环境
+   报过 `libmsgpackc.so.2`；即使 `module load` 之后也 import 不了。必须用
+   `srun`/`sbatch`。
 2. **忘了 `module load`** —— venv 激活前必须先
    `module load compiler/gcc/9.3.0 compiler/dtk/26.04`。
 3. **顺序错了** —— 先激活 venv 再 module load 也会失败，顺序必须是 module 在前。
@@ -84,6 +85,14 @@ Triton。DTK 26.04 的 HIP 运行时缺上游 ROCm 7 的 API，Triton 的 AMD ba
 即失败。**放弃这条路**，包括所有依赖 Triton kernel 的框架（SGLang FP8、vLLM ROCm
 MoE、transformers finegrained-fp8）。
 
+郑州集群最近还会先报另一种缺库：
+
+```
+ImportError: libgcvm.so.17git: cannot open shared object file
+```
+
+本质相同，都是 Triton 在当前 DTK/DCU 软件栈上不可用，不要继续调 Triton kernel。
+
 ### `torch._scaled_mm is only supported on CUDA devices with compute capability >= 9.0 or 8.9, or ROCm MI300+`
 
 gfx936 不支持硬件 FP8 计算。需要软件反量化（把 FP8 权重转成 BF16 再算）。
@@ -127,6 +136,24 @@ ROCM_PATH=未设置
 
 自检：作业里打印 `echo "ROCM_PATH=${ROCM_PATH:-未设置}"`，未设置就说明没生效。
 
+### `python3: command not found`（昆山计算节点）
+
+昆山计算节点 `module purge` 后没有 `python3` 命令，裸 `python` 是 Python 2，
+会再报：
+
+```
+SyntaxError: Non-ASCII character '\xe5' ... no encoding declared
+```
+
+修法：作业脚本里显式加载 Python 3 module：
+
+```bash
+module load python/3.8.10
+```
+
+`scripts/run-compute-probe.sh` 会自动从 `module avail` 探测 `python/3.*` 模块，
+但普通业务作业仍需在 `MODULE_LOADS` 或 `PYTHON_MODULE` 里带上。
+
 ### `TIMEOUT`
 
 `--time` 不够。注意大模型加载本身就很慢（DeepSeek V4 加载 154B 权重约 27 分钟），

package/skills/scnet-hpc/scripts/_common.sh

@@ -16,6 +16,25 @@ list_clusters() {
     find "$CLUSTER_DIR" -maxdepth 1 -name '*.conf' ! -name '_*' -exec basename {} .conf \; 2>/dev/null | sort
 }
 
+refresh_live_node_count() {
+    [ "${SCNET_HPC_LIVE_NODE_COUNT:-yes}" != "no" ] || return 0
+    [ "${SCHEDULER:-slurm}" = "slurm" ] || return 0
+    [ -n "${CLUSTER_ID:-}" ] || return 0
+    [ -n "${PARTITION:-}" ] || return 0
+
+    local live
+    live=$(ssh -o BatchMode=yes -o ConnectTimeout=10 -o ServerAliveInterval=15 -o ServerAliveCountMax=2 \
+        "$CLUSTER_ID" "scontrol show partition ${PARTITION}" 2>/dev/null \
+        | tr ' ' '\n' | sed -n 's/^TotalNodes=//p' | head -1)
+
+    if [[ "$live" =~ ^[0-9]+$ ]] && [ "$live" -gt 0 ]; then
+        NODE_COUNT="$live"
+        NODE_COUNT_SOURCE="live"
+    else
+        NODE_COUNT_SOURCE="${NODE_COUNT_SOURCE:-profile/cache}"
+    fi
+}
+
 load_cluster() {
     local want="${1:-}"
     local available
@@ -45,11 +64,32 @@ $(printf '%s\n' "$available" | sed 's/^/  /')"
     . "$conf"
 
     [ -n "${CLUSTER_ID:-}" ] || die "$conf 里 CLUSTER_ID 为空"
-    [ -n "${SSH_HOST:-}" ]   || die "$conf 里 SSH_HOST 为空"
     : "${SSH_PORT:=22}"
     : "${HOME_BASE:=/public/home}"
 
+    # SSH_HOST/SSH_PORT 应以 profile 为准。这里只作为兼容回退：
+    # 旧 profile 漏填时，从本机 ~/.ssh/config 动态补全，避免脚本直接失败。
+    if [ -z "${SSH_HOST:-}" ]; then
+        SSH_HOST="$(ssh -G "$CLUSTER_ID" 2>/dev/null | awk '/^hostname /{print $2; exit}')"
+    fi
+    if [ -z "${SSH_PORT:-}" ]; then
+        SSH_PORT="$(ssh -G "$CLUSTER_ID" 2>/dev/null | awk '/^port /{print $2; exit}')"
+    fi
+    REMOTE_USER_DETECTED="$(ssh -G "$CLUSTER_ID" 2>/dev/null | awk '/^user /{print $2; exit}')"
+    : "${REMOTE_USER_DETECTED:=}"
+
+    # 用于设置新连接的新集群仍需明确的 SSH_HOST/SSH_PORT；已有本机 ssh 别名时
+    # 这里会从 ssh -G 补齐。若仍为空，给一个可操作的错误。
+    [ -n "$SSH_HOST" ] || die "$conf 里 SSH_HOST 为空，且 ssh -G ${CLUSTER_ID} 也解析不到 HostName；请先配置 ~/.ssh/config 或补 profile。"
+
     CLUSTER_CONF="$conf"
+    CLUSTER_AUTO_CONF="$CLUSTER_DIR/.cache/$want.auto.conf"
+    if [ "${SCNET_HPC_USE_AUTO:-yes}" != "no" ] && [ -f "$CLUSTER_AUTO_CONF" ]; then
+        # shellcheck disable=SC1090
+        . "$CLUSTER_AUTO_CONF"
+    fi
+
+    refresh_live_node_count
 }
 
 # 从参数里摘出 --cluster <名>，剩下的放进 REST[]

package/skills/scnet-hpc/scripts/compute-probe.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+"""在目标计算节点上做一次最小能力探针。
+
+输出统一使用 PROBE_ 前缀的 KEY=value 行，方便 refresh-cluster.sh 解析。
+每个检查都独立捕获异常，单项失败不会中断后续检查。
+"""
+
+import os
+import urllib.request
+
+
+def emit(key, value):
+    print("PROBE_{}={}".format(key, value), flush=True)
+
+
+def short_error(exc, limit=180):
+    text = str(exc).replace("\n", " ")
+    return "{}:{}".format(type(exc).__name__, text[:limit])
+
+
+try:
+    import torch
+    emit("TORCH_VERSION", torch.__version__)
+    cuda_available = bool(torch.cuda.is_available())
+    emit("CUDA_AVAILABLE", "1" if cuda_available else "0")
+
+    if cuda_available:
+        count = torch.cuda.device_count()
+        emit("DEVICE_COUNT", count)
+
+        props = torch.cuda.get_device_properties(0)
+        emit("DEVICE_NAME", getattr(props, "name", "unknown").replace("\n", " "))
+
+        arch = getattr(props, "gcnArchName", None)
+        if arch is None:
+            arch = "{}.{}".format(getattr(props, "major", "?"), getattr(props, "minor", "?"))
+        emit("ARCH", arch)
+
+        total_memory = getattr(props, "total_memory", 0)
+        emit("MEM_MIB", int(total_memory // (1024 * 1024)))
+
+        have_dtypes = []
+        for dtype_name in ["float8_e4m3fn", "float8_e5m2", "float8_e8m0fnu", "bfloat16"]:
+            if hasattr(torch, dtype_name):
+                have_dtypes.append(dtype_name)
+        emit("DTYPES", ",".join(have_dtypes))
+
+        # 硬件 FP8 matmul
+        try:
+            if hasattr(torch, "float8_e4m3fn") and hasattr(torch, "_scaled_mm"):
+                a = torch.randn(64, 128).to(torch.float8_e4m3fn).cuda()
+                b = torch.randn(128, 64).to(torch.float8_e4m3fn).cuda().t().contiguous().t()
+                torch._scaled_mm(
+                    a,
+                    b,
+                    scale_a=torch.tensor(1.0).cuda(),
+                    scale_b=torch.tensor(1.0).cuda(),
+                    out_dtype=torch.bfloat16,
+                )
+                torch.cuda.synchronize()
+                emit("SCALED_MM", "OK")
+            else:
+                emit("SCALED_MM", "SKIP:float8_e4m3fn_or_scaled_mm_missing")
+        except Exception as exc:
+            emit("SCALED_MM", "ERR:" + short_error(exc))
+
+        # Triton 内核
+        try:
+            import triton
+            import triton.language as tl
+
+            @triton.jit
+            def add_kernel(x, y, out, n, BLOCK: tl.constexpr):
+                idx = tl.program_id(0) * BLOCK + tl.arange(0, BLOCK)
+                mask = idx < n
+                tl.store(out + idx, tl.load(x + idx, mask=mask) + tl.load(y + idx, mask=mask), mask=mask)
+
+            n = 4096
+            x = torch.randn(n, device="cuda")
+            y = torch.randn(n, device="cuda")
+            out = torch.empty_like(x)
+            add_kernel[(triton.cdiv(n, 256),)](x, y, out, n, BLOCK=256)
+            torch.cuda.synchronize()
+            max_err = float((out - (x + y)).abs().max().item())
+            emit("TRITON", "OK err={:.3g}".format(max_err))
+        except Exception as exc:
+            emit("TRITON", "ERR:" + short_error(exc, 240))
+
+        # bitsandbytes：先看能否 import；是否真正可用仍需业务级测试
+        try:
+            import bitsandbytes as bnb
+            emit("BITSANDBYTES", "IMPORT_OK version={}".format(getattr(bnb, "__version__", "unknown")))
+        except Exception as exc:
+            emit("BITSANDBYTES", "IMPORT_ERR:" + short_error(exc))
+    else:
+        emit("DEVICE_COUNT", 0)
+except Exception as exc:
+    emit("TORCH_IMPORT", "ERR:" + short_error(exc, 240))
+
+# 计算节点外网
+try:
+    urllib.request.urlopen("https://pypi.org", timeout=5)
+    emit("NET_PYPI", "ONLINE")
+except Exception:
+    emit("NET_PYPI", "OFFLINE")
+
+# /tmp 是否跨节点共享无法只靠单节点可靠判断，这里只记录文件系统信息
+try:
+    emit("TMP_FSTYPE", str(os.statvfs("/tmp").f_fsid))
+except Exception as exc:
+    emit("TMP_FSTYPE", "ERR:" + short_error(exc))
+emit("TMP_SHARED", "UNKNOWN")
+
+print("PROBE_EXIT=0", flush=True)

package/skills/scnet-hpc/scripts/new-job.sh

@@ -14,11 +14,15 @@ set -- "${REST[@]+${REST[@]}}"
 
 # --user <名>：远端用户名与本地不同时指定（日志路径需要真实用户名）
 REMOTE_USER=""
+REFRESH=no
+USE_AUTO=yes
 ARGS=()
 while [ $# -gt 0 ]; do
     case "$1" in
         --user) REMOTE_USER="${2:-}"; shift 2 ;;
         --user=*) REMOTE_USER="${1#*=}"; shift ;;
+        --refresh) REFRESH=yes; shift ;;
+        --no-auto) USE_AUTO=no; shift ;;
         *) ARGS+=("$1"); shift ;;
     esac
 done
@@ -31,7 +35,7 @@ TIME="${4:-00:20:00}"
 
 if [ -z "$NAME" ]; then
     cat >&2 <<EOF
-用法: $0 [--cluster <集群短名>] [--user <远端用户名>] <作业名> [加速器数] [cpu数] [时长]
+用法: $0 [--cluster <集群短名>] [--user <远端用户名>] [--refresh|--no-auto] <作业名> [加速器数] [cpu数] [时长]
 
 例子:
   $0 probe                    # 1 卡, 8 核, 20 分钟（探针）
@@ -42,6 +46,11 @@ EOF
     exit 1
 fi
 
+if [ "$REFRESH" = yes ]; then
+    "$REPO_ROOT/scripts/refresh-cluster.sh" --cluster "${CLUSTER:-}"
+fi
+
+export SCNET_HPC_USE_AUTO="$USE_AUTO"
 load_cluster "$CLUSTER"
 
 [ "${SCHEDULER:-slurm}" = "slurm" ] \
@@ -69,7 +78,7 @@ fi
 # 远端用户名。#SBATCH 是注释行，Slurm 不做变量展开 —— 日志路径里写 $USER
 # 会被当成字面量目录名，作业以 exit 53 失败且不产生日志。所以这里必须展开成
 # 真实用户名。默认取本地用户名，不同时用 --user 覆盖。
-REMOTE_USER="${REMOTE_USER:-$(whoami)}"
+REMOTE_USER="${REMOTE_USER:-${REMOTE_USER_DETECTED:-$(whoami)}}"
 HOME_DIR="${HOME_BASE}/${REMOTE_USER}"
 
 # 脚本体（非 #SBATCH 行）里可以正常用 $USER
@@ -137,6 +146,7 @@ sed -i.bak '/^$/N;/^\n$/D' "$OUT" 2>/dev/null && rm -f "$OUT.bak"
 
 echo "已生成 $OUT"
 echo "  集群=${CLUSTER_ID}  ${GRES_TYPE:-加速器}=${ACCEL}  CPU=${CPUS}  内存=${MEM_NOTE}  时长=${TIME}"
+echo "  分区=${PARTITION:-未设置}  节点数=${NODE_COUNT:-未探测}（来源：${NODE_COUNT_SOURCE:-profile/cache}）"
 echo "  日志目录=${HOME_DIR}/scripts/logs（用户名 ${REMOTE_USER}，不对请加 --user）"
 echo
 echo "上传并提交："

package/skills/scnet-hpc/scripts/refresh-cluster.sh

@@ -0,0 +1,277 @@
+#!/usr/bin/env bash
+# 动态刷新 clusters/.cache/<集群>.auto.conf。
+#
+# 用法：
+#   ./refresh-cluster.sh [--cluster <集群短名>] [--compute] [--dry-run]
+#
+# 默认只做登录节点上的只读探测；--compute 会提交一个 1 卡、4 核、10 分钟的小作业，
+# 到计算节点实测加速器、Triton、FP8、外网等能力。生成的缓存会覆盖 profile 的同名字段。
+
+set -euo pipefail
+
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/_common.sh"
+
+parse_cluster_arg "$@"
+set -- "${REST[@]+${REST[@]}}"
+
+COMPUTE=no
+DRY_RUN=no
+
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --compute|-c) COMPUTE=yes; shift ;;
+        --dry-run|-n) DRY_RUN=yes; shift ;;
+        -h|--help) sed -n '2,14p' "$0" | sed 's/^# \?//'; exit 0 ;;
+        *) die "未知参数: $1" ;;
+    esac
+done
+
+load_cluster "$CLUSTER"
+
+r() {
+    ssh -o BatchMode=yes -o ConnectTimeout=15 -o ServerAliveInterval=15 -o ServerAliveCountMax=3 \
+        "$CLUSTER_ID" "$1" 2>/dev/null || true
+}
+
+probe_value() {
+    local key="$1"
+    printf '%s\n' "${COMPUTE_OUT:-}" | awk -F= -v k="$key" '$1 == k { sub(/^[^=]+=/,""); print; exit }'
+}
+
+add_known_limit() {
+    local item="$1"
+    [ -n "$item" ] || return 0
+    case "$item" in
+        *Triton*)
+            if printf '%s' "$KNOWN_LIMITS_NEW" | grep -q 'Triton'; then return 0; fi
+            ;;
+        *FP8*)
+            if printf '%s' "$KNOWN_LIMITS_NEW" | grep -q 'FP8'; then return 0; fi
+            ;;
+        *BF16*)
+            if printf '%s' "$KNOWN_LIMITS_NEW" | grep -q 'BF16'; then return 0; fi
+            ;;
+        *bitsandbytes*)
+            if printf '%s' "$KNOWN_LIMITS_NEW" | grep -q 'bitsandbytes'; then return 0; fi
+            ;;
+    esac
+    KNOWN_LIMITS_NEW="${KNOWN_LIMITS_NEW:+${KNOWN_LIMITS_NEW}；}${item}"
+}
+
+info "==> 动态探测 ${CLUSTER_ID} (${CLUSTER_DESC:-$SSH_HOST})"
+probe_ok=$(r 'echo yes')
+[ "$probe_ok" = "yes" ] || die "无法通过 ssh 连接 ${CLUSTER_ID}"
+
+# ---- 连接和登录节点基础信息 ----
+DETECTED_HOST="$(ssh -G "$CLUSTER_ID" 2>/dev/null | awk '/^hostname /{print $2; exit}')"
+DETECTED_PORT="$(ssh -G "$CLUSTER_ID" 2>/dev/null | awk '/^port /{print $2; exit}')"
+DETECTED_USER="$(ssh -G "$CLUSTER_ID" 2>/dev/null | awk '/^user /{print $2; exit}')"
+LOGIN_HOST=$(r 'hostname')
+REMOTE_HOME=$(r 'echo $HOME')
+HOME_BASE_NEW=$(dirname "$REMOTE_HOME")
+CPU_MODEL_NEW=$(r "lscpu | sed -n 's/^Model name:[[:space:]]*//p' | head -1")
+QUOTA_NEW=$(r "df -BG $REMOTE_HOME 2>/dev/null | awk 'NR==2{gsub(/[^0-9]/,\"\",\$2); print \$2}'")
+
+# ---- 调度器 ----
+SCHED_NEW="unknown"
+if [ -n "$(r 'command -v sbatch')" ]; then
+    SCHED_NEW="slurm"
+elif [ -n "$(r 'command -v qsub')" ]; then
+    SCHED_NEW="pbs"
+fi
+
+PART_NEW=""
+DEFMEM_NEW=""
+MAXWALL_NEW=""
+MINGRES_NEW=""
+GRESTYPE_NEW=""
+NODECNT_NEW=""
+CPUS_NEW=""
+NODEMEM_NEW=""
+ACCEL_NEW=""
+
+if [ "$SCHED_NEW" = "slurm" ]; then
+    # 优先沿用 profile 现有分区，只在它已经不再 up 时才改选第一个 up 分区。
+    if [ -n "${PARTITION:-}" ]; then
+        PART_STATE=$(r "sinfo -h -p ${PARTITION} -o '%a' | head -1")
+        [ "$PART_STATE" = "up" ] && PART_NEW="$PARTITION"
+    fi
+    if [ -z "$PART_NEW" ]; then
+        PART_NEW=$(r "sinfo -h -o '%P %a' | awk '\$2==\"up\"{print \$1; exit}'" | tr -d '*')
+    fi
+
+    if [ -n "$PART_NEW" ]; then
+        SCON=$(r "scontrol show partition $PART_NEW")
+        DEFMEM_NEW=$(printf '%s' "$SCON" | tr ' ' '\n' | sed -n 's/^DefMemPerCPU=//p' | head -1)
+        MAXWALL_NEW=$(printf '%s' "$SCON" | tr ' ' '\n' | sed -n 's/^MaxTime=//p' | head -1)
+        NODECNT_NEW=$(printf '%s' "$SCON" | tr ' ' '\n' | sed -n 's/^TotalNodes=//p' | head -1)
+
+        QOS_NEW=$(printf '%s' "$SCON" | tr ' ' '\n' | sed -n 's/^QoS=//p' | head -1)
+        if [ -n "$QOS_NEW" ] && [ "$QOS_NEW" != "N/A" ]; then
+            MINTRES=$(r "sacctmgr -nP show qos where name=$QOS_NEW format=MinTRES")
+            MINGRES_NEW=$(printf '%s' "$MINTRES" | sed -n 's|.*gres/\([a-z]*\)=\([0-9]*\).*|\1:\2|p')
+        fi
+
+        NODEINFO=$(r "sinfo -h -p $PART_NEW -o '%c|%m|%G' | head -1")
+        CPUS_NEW=$(printf '%s' "$NODEINFO" | cut -d'|' -f1)
+        NODEMEM_NEW=$(printf '%s' "$NODEINFO" | cut -d'|' -f2 | awk '{printf "%d", $1/1024}')
+        GRESRAW=$(printf '%s' "$NODEINFO" | cut -d'|' -f3)
+        GRESBASE=${GRESRAW%%(*}
+        GRESTYPE_NEW=$(printf '%s' "$GRESBASE" | cut -d: -f1)
+        ACCEL_NEW=$(printf '%s' "$GRESBASE" | awk -F: '{print $NF}' | tr -dc '0-9')
+    fi
+fi
+
+# ---- 登录节点网络 ----
+NET_OK_NEW=""
+NET_BLOCKED_NEW=""
+for h in pypi.org pypi.tuna.tsinghua.edu.cn modelscope.cn huggingface.co github.com; do
+    reachable=no
+    for _ in 1 2; do
+        code=$(r "timeout 15 curl -sI https://$h -o /dev/null -w '%{http_code}'")
+        case "$code" in
+            2*|3*) reachable=yes; break ;;
+        esac
+    done
+    if [ "$reachable" = yes ]; then
+        NET_OK_NEW="${NET_OK_NEW:+$NET_OK_NEW }$h"
+    else
+        NET_BLOCKED_NEW="${NET_BLOCKED_NEW:+$NET_BLOCKED_NEW }$h"
+    fi
+done
+
+# ---- 登录节点 torch 缺库 ----
+torch_login=$(r 'python3 -c "import torch" 2>&1 | tail -1')
+MISSING_LIB_NEW=$(printf '%s' "$torch_login" | sed -n 's/^ImportError: \([^:]*\.so[^:]*\).*/\1/p')
+
+# ---- module 候选（只记录，不自动覆盖 MODULE_LOADS）----
+MODULE_CANDIDATES_NEW=$(r "bash -lc 'module avail 2>&1' | awk '/compiler\\/(dtk|rocm)/{print}' | sort -u | head -30")
+
+# ---- 计算节点能力（可选）----
+COMPUTE_OUT=""
+ACCEL_NAME_NEW=""
+ACCEL_ARCH_NEW=""
+ACCEL_MEM_NEW=""
+COMPUTE_OFFLINE_NEW=""
+KNOWN_LIMITS_NEW=""
+
+if [ "$COMPUTE" = yes ] && [ "$DRY_RUN" = no ]; then
+    info "==> 提交计算节点小探针（约 1 卡、4 核、10 分钟）"
+    COMPUTE_OUT="$( { "$REPO_ROOT/scripts/run-compute-probe.sh" --cluster "$CLUSTER_ID"; } 2>&1 )" || true
+    if ! printf '%s\n' "$COMPUTE_OUT" | grep -q '^PROBE_'; then
+        info "计算节点探针未产生有效 PROBE 输出："
+        printf '%s\n' "$COMPUTE_OUT" | sed 's/^/    /' >&2
+        COMPUTE_OUT=""
+    fi
+fi
+
+if [ "$COMPUTE" = yes ] && [ -n "$COMPUTE_OUT" ]; then
+    CUDA_AVAILABLE=$(probe_value PROBE_CUDA_AVAILABLE)
+    ACCEL_NAME_NEW=$(probe_value PROBE_DEVICE_NAME)
+    case "$ACCEL_NAME_NEW" in
+        BW|BW1000) ACCEL_NAME_NEW="海光 BW1000 DCU" ;;
+    esac
+    ACCEL_ARCH_NEW=$(probe_value PROBE_ARCH)
+
+    MEM_MIB=$(probe_value PROBE_MEM_MIB)
+    if [[ "$MEM_MIB" =~ ^[0-9]+$ ]]; then
+        ACCEL_MEM_NEW=$(( (MEM_MIB + 1023) / 1024 ))
+    fi
+
+    case "$(probe_value PROBE_NET_PYPI)" in
+        OFFLINE) COMPUTE_OFFLINE_NEW=yes ;;
+        ONLINE) COMPUTE_OFFLINE_NEW=no ;;
+    esac
+
+    if [ "$CUDA_AVAILABLE" = "0" ]; then
+        KNOWN_LIMITS_NEW="torch.cuda 不可用"
+    fi
+
+    DTYPES=$(probe_value PROBE_DTYPES)
+    case ",$DTYPES," in
+        *,bfloat16,*) ;;
+        *) KNOWN_LIMITS_NEW="${KNOWN_LIMITS_NEW:+${KNOWN_LIMITS_NEW}；}无 BF16 数据类型支持" ;;
+    esac
+
+    SCALED=$(probe_value PROBE_SCALED_MM)
+    case "$SCALED" in
+        ERR:*) KNOWN_LIMITS_NEW="${KNOWN_LIMITS_NEW:+${KNOWN_LIMITS_NEW}；}硬件 FP8 torch._scaled_mm 不可用（${SCALED}）" ;;
+    esac
+
+    TRITON=$(probe_value PROBE_TRITON)
+    case "$TRITON" in
+        ERR:*) KNOWN_LIMITS_NEW="${KNOWN_LIMITS_NEW:+${KNOWN_LIMITS_NEW}；}Triton 不可用（${TRITON}）" ;;
+    esac
+
+    BNB=$(probe_value PROBE_BITSANDBYTES)
+    case "$BNB" in
+        IMPORT_ERR:*) KNOWN_LIMITS_NEW="${KNOWN_LIMITS_NEW:+${KNOWN_LIMITS_NEW}；}bitsandbytes 导入失败（${BNB}）" ;;
+    esac
+
+    # 保留 profile 里已有的人工经验，动态结果放前面。
+    if [ -n "${KNOWN_LIMITATIONS:-}" ]; then
+        OLD_IFS="$IFS"
+        IFS='；'
+        for item in $KNOWN_LIMITATIONS; do
+            add_known_limit "$item"
+        done
+        IFS="$OLD_IFS"
+    fi
+elif [ "$COMPUTE" = yes ]; then
+    info "计算节点探针没有返回结果，保留 profile 中的加速器和限制信息。"
+fi
+
+build_cache() {
+    echo "# 由 scripts/refresh-cluster.sh 自动生成于 $(date '+%Y-%m-%d %H:%M:%S')"
+    echo "# 登录节点: ${LOGIN_HOST:-未探测}"
+    echo "# 这是动态探测缓存，会覆盖 profile 中的同名字段；删除本文件即可回退到纯 profile。"
+    printf 'SSH_HOST=%q\n' "${DETECTED_HOST:-$SSH_HOST}"
+    printf 'SSH_PORT=%q\n' "${DETECTED_PORT:-$SSH_PORT}"
+    printf 'REMOTE_USER_DETECTED=%q\n' "${DETECTED_USER:-${REMOTE_USER_DETECTED:-}}"
+    printf 'HOME_BASE=%q\n' "${HOME_BASE_NEW:-$HOME_BASE}"
+    printf 'SCHEDULER=%q\n' "${SCHED_NEW:-${SCHEDULER:-}}"
+    printf 'PARTITION=%q\n' "${PART_NEW:-${PARTITION:-}}"
+    printf 'DEF_MEM_PER_CPU=%q\n' "${DEFMEM_NEW:-${DEF_MEM_PER_CPU:-}}"
+    printf 'MIN_GRES=%q\n' "${MINGRES_NEW:-${MIN_GRES:-}}"
+    printf 'GRES_TYPE=%q\n' "${GRESTYPE_NEW:-${GRES_TYPE:-}}"
+    printf 'MAX_WALLTIME=%q\n' "${MAXWALL_NEW:-${MAX_WALLTIME:-}}"
+    printf 'CPUS_PER_NODE=%q\n' "${CPUS_NEW:-${CPUS_PER_NODE:-}}"
+    printf 'NODE_MEM_GB=%q\n' "${NODEMEM_NEW:-${NODE_MEM_GB:-}}"
+    printf 'NODE_COUNT=%q\n' "${NODECNT_NEW:-${NODE_COUNT:-}}"
+    printf 'ACCEL_PER_NODE=%q\n' "${ACCEL_NEW:-${ACCEL_PER_NODE:-}}"
+    printf 'CPU_MODEL=%q\n' "${CPU_MODEL_NEW:-${CPU_MODEL:-}}"
+    printf 'LOGIN_NODES=%q\n' "${LOGIN_HOST:-${LOGIN_NODES:-}}"
+    printf 'HOME_QUOTA_GB=%q\n' "${QUOTA_NEW:-${HOME_QUOTA_GB:-}}"
+    printf 'NET_OK=%q\n' "${NET_OK_NEW:-${NET_OK:-}}"
+    printf 'NET_BLOCKED=%q\n' "${NET_BLOCKED_NEW:-${NET_BLOCKED:-}}"
+    printf 'LOGIN_NODE_MISSING_LIBS=%q\n' "${MISSING_LIB_NEW:-${LOGIN_NODE_MISSING_LIBS:-}}"
+    printf 'MODULE_CANDIDATES=%q\n' "${MODULE_CANDIDATES_NEW:-}"
+
+    if [ "$COMPUTE" = yes ]; then
+        printf 'ACCEL_NAME=%q\n' "${ACCEL_NAME_NEW:-${ACCEL_NAME:-}}"
+        printf 'ACCEL_ARCH=%q\n' "${ACCEL_ARCH_NEW:-${ACCEL_ARCH:-}}"
+        printf 'ACCEL_MEM_GB=%q\n' "${ACCEL_MEM_NEW:-${ACCEL_MEM_GB:-}}"
+        printf 'COMPUTE_NODE_OFFLINE=%q\n' "${COMPUTE_OFFLINE_NEW:-${COMPUTE_NODE_OFFLINE:-}}"
+        printf 'KNOWN_LIMITATIONS=%q\n' "${KNOWN_LIMITS_NEW:-${KNOWN_LIMITATIONS:-}}"
+    else
+        printf 'COMPUTE_NODE_OFFLINE=%q\n' "${COMPUTE_NODE_OFFLINE:-}"
+        printf 'KNOWN_LIMITATIONS=%q\n' "${KNOWN_LIMITATIONS:-}"
+    fi
+}
+
+mkdir -p "$CLUSTER_DIR/.cache"
+if [ "$DRY_RUN" = yes ]; then
+    info "==> dry-run，不写缓存"
+    build_cache
+else
+    AUTO_TMP="$CLUSTER_AUTO_CONF.tmp.$$"
+    build_cache > "$AUTO_TMP"
+    mv "$AUTO_TMP" "$CLUSTER_AUTO_CONF"
+    info "==> 已写入 $CLUSTER_AUTO_CONF"
+
+    if [ "$COMPUTE" = yes ] && [ -n "$COMPUTE_OUT" ]; then
+        PROBE_LOG="$CLUSTER_DIR/.cache/${CLUSTER_ID}.probe.log"
+        printf '%s\n' "$COMPUTE_OUT" > "$PROBE_LOG"
+        info "==> 原始探针输出已保存 $PROBE_LOG"
+    fi
+fi

package/skills/scnet-hpc/scripts/run-compute-probe.sh

@@ -0,0 +1,132 @@
+#!/usr/bin/env bash
+# 在目标集群计算节点运行一次最小能力探针，输出 PROBE_ 开头的解析结果。
+#
+# 用法：
+#   ./run-compute-probe.sh [--cluster <集群短名>] [--cpus 4] [--time 00:10:00] [--accelerators 1]
+
+set -euo pipefail
+
+. "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/_common.sh"
+
+parse_cluster_arg "$@"
+set -- "${REST[@]+${REST[@]}}"
+
+CPUS=4
+TIME=00:10:00
+ACCEL=1
+REMOTE_USER=""
+PYTHON_BIN=""
+
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --cpus) CPUS="${2:-$CPUS}"; shift 2 ;;
+        --cpus=*) CPUS="${1#*=}"; shift ;;
+        --time) TIME="${2:-$TIME}"; shift 2 ;;
+        --time=*) TIME="${1#*=}"; shift ;;
+        --accelerators) ACCEL="${2:-$ACCEL}"; shift 2 ;;
+        --accelerators=*) ACCEL="${1#*=}"; shift ;;
+        --user) REMOTE_USER="${2:-}"; shift 2 ;;
+        --user=*) REMOTE_USER="${1#*=}"; shift ;;
+        --python) PYTHON_BIN="${2:-}"; shift 2 ;;
+        --python=*) PYTHON_BIN="${1#*=}"; shift ;;
+        -h|--help) sed -n '2,10p' "$0" | sed 's/^# \?//'; exit 0 ;;
+        *) die "未知参数: $1" ;;
+    esac
+done
+
+[ -n "${CLUSTER:-}" ] || die "请用 --cluster <集群短名> 指定集群。"
+load_cluster "$CLUSTER"
+
+[ "${SCHEDULER:-slurm}" = "slurm" ] || die "${CLUSTER_ID} 不是 Slurm 调度器，暂不支持自动计算节点探针。"
+[ -n "${PARTITION:-}" ] || die "${CLUSTER_ID} 的 PARTITION 为空，无法提交计算节点探针。"
+
+REMOTE_USER="${REMOTE_USER:-${REMOTE_USER_DETECTED:-$(whoami)}}"
+HOME_DIR="${HOME_BASE}/${REMOTE_USER}"
+PROBE_BASE="${HOME_DIR}/scnet-hpc-probe"
+
+ssh_cmd() { ssh -o BatchMode=yes -o ConnectTimeout=20 -o ServerAliveInterval=15 -o ServerAliveCountMax=3 "$@"; }
+scp_cmd() { scp -o BatchMode=yes -o ConnectTimeout=20 "$@"; }
+
+PYTHON_MODULE_LINE=""
+if [ -z "${PYTHON_MODULE:-}" ]; then
+    PYTHON_MODULE_DETECTED="$(ssh_cmd "$CLUSTER_ID" "bash -lc 'module avail 2>&1'" 2>/dev/null \
+        | awk '/^(python|apps\/python)\/3\./{print $1; exit}')"
+    [ -n "$PYTHON_MODULE_DETECTED" ] && PYTHON_MODULE="$PYTHON_MODULE_DETECTED"
+fi
+[ -n "${PYTHON_MODULE:-}" ] && PYTHON_MODULE_LINE="module load ${PYTHON_MODULE}"
+
+MEM_LINE=""
+if [ -n "${DEF_MEM_PER_CPU:-}" ]; then
+    MEM_MB=$(( CPUS * DEF_MEM_PER_CPU ))
+    MEM_GB=$(( MEM_MB / 1024 ))
+    [ "$MEM_GB" -gt 1 ] && MEM_GB=$(( MEM_GB - 1 ))
+    MEM_LINE="#SBATCH --mem=${MEM_GB}gb"
+fi
+
+GRES_LINE=""
+if [ -n "${GRES_TYPE:-}" ]; then
+    GRES_LINE="#SBATCH --gres=${GRES_TYPE}:${ACCEL}"
+fi
+
+MODULE_LINE=""
+[ -n "${MODULE_LOADS:-}" ] && MODULE_LINE="module load ${MODULE_LOADS}"
+
+VENV_LINE=""
+[ -n "${DEFAULT_VENV:-}" ] && VENV_LINE="source ${HOME_DIR}/${DEFAULT_VENV}/bin/activate"
+
+TMPDIR_LOCAL=$(mktemp -d)
+trap 'rm -rf "$TMPDIR_LOCAL"' EXIT
+cp "$REPO_ROOT/scripts/compute-probe.py" "$TMPDIR_LOCAL/compute-probe.py"
+
+cat > "$TMPDIR_LOCAL/probe.slurm" <<EOF
+#!/bin/bash -l
+#SBATCH --job-name=scnet_hpc_probe
+#SBATCH --partition=${PARTITION}
+#SBATCH --nodes=1
+#SBATCH --ntasks-per-node=1
+#SBATCH --cpus-per-task=${CPUS}
+${GRES_LINE}
+${MEM_LINE}
+#SBATCH --time=${TIME}
+#SBATCH --output=${HOME_DIR}/scripts/logs/scnet-hpc-probe_%j.out
+#SBATCH --error=${HOME_DIR}/scripts/logs/scnet-hpc-probe_%j.err
+
+module purge
+${MODULE_LINE}
+${PYTHON_MODULE_LINE}
+${VENV_LINE}
+export HF_HUB_OFFLINE=1
+export TRANSFORMERS_OFFLINE=1
+
+# 部分集群 module purge 后没有 python3 这个命令，按候选名兜底找 Python。
+PYTHON_BIN="${PYTHON_BIN}"
+if [ -z "\$PYTHON_BIN" ]; then
+    for candidate in python3 python3.8 python3.9 python3.10 python3.11; do
+        if command -v "\$candidate" >/dev/null 2>&1; then
+            PYTHON_BIN="\$candidate"
+            break
+        fi
+    done
+fi
+[ -n "\$PYTHON_BIN" ] || { echo "PYTHON_NOT_FOUND" >&2; exit 127; }
+"\$PYTHON_BIN" ${PROBE_BASE}.py
+rc=\$?
+echo "PROBE_EXIT=\$rc"
+exit \$rc
+EOF
+
+ssh_cmd "$CLUSTER_ID" "mkdir -p ${HOME_DIR}/scripts/logs"
+scp_cmd -q "$TMPDIR_LOCAL/compute-probe.py" "${CLUSTER_ID}:${PROBE_BASE}.py"
+scp_cmd -q "$TMPDIR_LOCAL/probe.slurm" "${CLUSTER_ID}:${PROBE_BASE}.slurm"
+
+JOBID=$(ssh_cmd "$CLUSTER_ID" "cd ${HOME_DIR} && sbatch --parsable --wait ${PROBE_BASE}.slurm" | tail -1)
+OUT=$(ssh_cmd "$CLUSTER_ID" "cat ${HOME_DIR}/scripts/logs/scnet-hpc-probe_${JOBID}.out" 2>/dev/null || true)
+ERR=$(ssh_cmd "$CLUSTER_ID" "cat ${HOME_DIR}/scripts/logs/scnet-hpc-probe_${JOBID}.err" 2>/dev/null || true)
+
+if [ -n "$OUT" ]; then
+    printf '%s\n' "$OUT"
+else
+    printf '%s\n' "$ERR" >&2
+fi
+
+ssh_cmd "$CLUSTER_ID" "rm -f ${PROBE_BASE}.py ${PROBE_BASE}.slurm ${HOME_DIR}/scripts/logs/scnet-hpc-probe_${JOBID}.out ${HOME_DIR}/scripts/logs/scnet-hpc-probe_${JOBID}.err"

package/skills/scnet-hpc/scripts/setup-ssh.sh

@@ -28,7 +28,9 @@ EOF
     exit 1
 fi
 
+SCNET_HPC_LIVE_NODE_COUNT=no
 load_cluster "$CLUSTER"
+unset SCNET_HPC_LIVE_NODE_COUNT
 
 [ -f "$KEY_SRC" ] || die "找不到私钥文件: $KEY_SRC"
 grep -q "BEGIN.*PRIVATE KEY" "$KEY_SRC" \