@yanglaofish/dsh-proxy-pro 1.0.6 → 1.0.8

package/docs/LESSONS.md

@@ -750,4 +750,68 @@ scope.watch(() => { void requestSync().catch(() => {}) })
 
 **教训**：① ESM 顶层 import 命中断言是**加载期**错误——一次错误的 import 能杀死整个进程，所以
 对外部包的导出要查运行环境的实际版本，而不是凭记忆；② 能从服务拿到的（settings 是 inject 服务）
-就不要 import 包；③ 「桌面版」与「全局 CLI 版」是两套依赖树，一个功能必须两端都能加载。
+就不要 import 包；③ 「桌面版」与「全局 CLI 版」是两套依赖树，一个功能必须两端都能加载。
+
+---
+
+## 27. HEAD 404 ≠ 路径不存在：探测必须 GET 复测（2026-09-18）
+
+**症状**：面板测 `https://dashscope.aliyuncs.com/compatible-mode/v1` 和 `.../v1/models`
+一律显示「降级 — HTTP 404 — 路径不存在」；连测几个厂商的 API 都是 404，用户开始怀疑
+「是不是网络不可达」。
+
+**真相**（实测对照）：
+
+| 请求 | DashScope 应答 |
+| --- | --- |
+| GET `/compatible-mode/v1/models` | **401**（端点存在，只缺 API Key） |
+| GET `/compatible-mode/v1/chat/completions` | **400**（端点存在，请求不合法） |
+| GET `/` | 404 |
+| HEAD `/compatible-mode/v1/models` | **404** ← 同一个端点！ |
+
+网关不给 HEAD 注册路由，对 HEAD 一律回 404；而 404 被探测当成「路径不存在」，健康的
+API 端点就这样被误判。**404 从来不是「网络不可达」的证据**——它恰恰证明拿到了 HTTP 应答
+（真正的不可达是 ENOTFOUND/ECONNREFUSED/ETIMEDOUT/代理 407）。
+
+**改法**（1.0.7）：回退条件从 405/501 扩到 **404/405/501**，提为纯函数
+`headNeedsGetRetry(status)`（proxy-core，可单测）。GET 复测带 `Range: bytes=0-0` 只取首
+字节，代价极小；note 写明「HEAD 返回 X，GET 得到 Y — 以 GET 为准」。404 的 why/fix 改为
+「HEAD 与 GET 都 404」并引导换真实完整端点复测。
+
+**教训**：① 探测方法本身就是误判来源——HEAD「轻量」不等于「等价」；② 把 404 当「不存在」
+之前先问「服务器认不认这个方法」；③ 状态码是二手的，链路层结论只能由「是否拿到 HTTP
+应答」给出。
+
+---
+
+## 28. 发布铁律：每次 npm publish 后必须主动强制触发淘宝源同步（用户定案，2026-09-18）
+
+**用户的规矩（说了两次，不可违背）**：每次我们更新 npm 包（publish 成功）后，**必须手动
+主动触发淘宝源（npmmirror）更新，不许等待**——用户原话「每次更新了 npm，都请你手动强制
+触发淘宝源更新」「不要等待，就是走淘宝的主动同步」。
+
+**为什么**：npmmirror 自己拉取官方源有队列延迟，干等（只 PUT 一次 syncs 然后 poll）会 stuck
+几分钟甚至更久，导致 `dsh plugin add <新版本>` 在淘宝源上解析不到。**主动循环触发**（每轮
+先 PUT syncs、再 poll）实测 1.0.5=11 轮、1.0.6=13 轮、1.0.7=33 轮（约 2-4 分钟）必定拉到。
+
+**标准流程（每一步都要做）**：
+1. `npm publish --access=public --registry=https://registry.npmjs.org --replace-registry-host=never` 成功；
+2. 循环最多 60 轮：`PUT https://registry.npmmirror.com/-/package/@yanglaofish%2Fdsh-proxy-pro/syncs`
+   带 body `{"version":"<新版本>"}`（ContentType application/json），随后
+   `GET https://registry.npmmirror.com/@yanglaofish%2Fdsh-proxy-pro` 看 `dist-tags.latest`；
+   每轮间隔 8-10s，**一直循环到 latest == 新版本**（不许提前放弃）；
+3. latest 到位后立即：`dsh plugin --profile test add '@yanglaofish/dsh-proxy-pro@^<新版本>'`
+   与 `dsh plugin --profile web add ...`，并验证两个 profile 的 node_modules 版本。
+
+**教训**：① 「PUT syncs 返回 201」只是入队确认，不是同步完成——以 `dist-tags.latest` 为准；
+② 官方 registry 先可见不代表淘宝可见，淘宝拉取是独立队列；③ 用户规则优先于"省事"——主动
+触发是默认动作，不是可选优化。
+
+**补充：git push 的代理必须与「被暖窗的代理」一致（2026-09-18 实测）**：git 全局配置里写死的
+`http.proxy=http://proxyhk.huawei.com:8080` 是历史遗留——当前网络环境该代理已 407 失效，
+而系统代理是 `proxyza`（南非）。正确姿势：push 前用 `Invoke-WebRequest https://github.com`
+暖**当前系统代理**（.NET 自动 NTLM），然后 `git -c http.proxy=http://<当前系统代理> push`
+（用 `-c` 临时覆盖写死的 config）。若暖窗对象与 git 实际走的代理不一致，必然 407 CONNECT
+tunnel failed（proxyhk 暖窗 407、proxyza 暖窗 200 → 只有后者能推成功）。长期可选：
+`git config --global --unset http.proxy` 让 git 走插件写入的 `http_proxy` 环境变量（动态跟随
+当前系统代理），注意 CLI 环境无插件时需手动 `-c` 指定。

package/docs/SPEC.md

@@ -199,7 +199,9 @@ installProxyFromEnvironment 的 none-branch 完成：恢复首次安装前的 en
 
 `proxy_test` 内部：`proxyRouteFor(parsed)` 判路由名（try/catch，不可用时回退快照
 推导）→ NO_PROXY 列表命中判断 → `fetch(url, {method:'HEAD', redirect:'manual'})`
-实测 6s 超时（AbortController）→ `classifyTargetFailure` 归类
+实测 6s 超时（AbortController）；HEAD 状态为 404/405/501 时按 `headNeedsGetRetry`
+用 GET（`Range: bytes=0-0`）复测并以 GET 为准（LESSONS §27：网关常不给 HEAD 注册
+路由，HEAD 404 ≠ 路径不存在）→ `classifyTargetFailure` 归类
 （EACCES/ENETUNREACH/EHOSTUNREACH → "needs a proxy route"；407/NTLM → auth）。
 
 ### 4.7 系统提示段落

package/lib/client.js

@@ -74,9 +74,15 @@ window.__ModuleLoader__.load({
       ".dsxprx-diagwhy{font-size:12px;line-height:17px;color:var(--dsw-alias-label-secondary)}",
       ".dsxprx-diagfix{font-size:12px;line-height:17px;color:var(--dsw-alias-label-primary)}",
       ".dsxprx-diagnote{font-size:11px;line-height:16px;color:var(--dsw-alias-label-caption)}",
+      ".dsxprx-verdict{display:inline-flex;align-items:center;gap:6px;padding:2px 10px;border-radius:999px;font-weight:600;font-size:12px;line-height:18px}",
+      ".dsxprx-verdict[data-tone=ok]{background:rgba(16,185,129,.12);color:var(--dsw-alias-state-success-primary,#10b981)}",
+      ".dsxprx-verdict[data-tone=warn]{background:rgba(245,158,11,.14);color:#f59e0b}",
+      ".dsxprx-verdict[data-tone=bad]{background:rgba(239,68,68,.12);color:var(--dsw-alias-state-error-primary,#ef4444)}",
+      ".dsxprx-diagprobe{display:flex;align-items:center;gap:8px;flex-wrap:wrap}",
+      ".dsxprx-diotag{flex:none;min-width:44px;font-size:12px;line-height:17px;color:var(--dsw-alias-label-caption)}",
+      ".dsxprx-verdictlarge{font-size:13px;font-weight:600;line-height:19px;color:var(--dsw-alias-label-primary)}",
+      ".dsxprx-diagverdict{display:flex;flex-direction:column;gap:3px;padding:6px 0 2px;border-top:1px dashed var(--dsw-alias-border-l1)}",
       ".dsxprx-title{font-size:16px;font-weight:700;line-height:22px;color:var(--dsw-alias-label-primary)}",
-      ".dsxprx-diagcheck{flex:none;display:flex;align-items:center;gap:5px;font-size:12px;line-height:16px;color:var(--dsw-alias-label-secondary);cursor:pointer;white-space:nowrap}",
-      ".dsxprx-diagcheck input{width:14px;height:14px;accent-color:#4d6bfe;margin:0}",
       ".dsxprx-hdr{display:flex;align-items:center;gap:6px;max-width:180px;height:26px;padding:0 10px;border:1px solid var(--dsw-alias-border-l1);border-radius:999px;background:transparent;color:var(--dsw-alias-label-primary);font:inherit;font-size:12px;line-height:16px;cursor:pointer;white-space:nowrap;overflow:hidden}",
       ".dsxprx-hdr:hover{background:var(--dsw-alias-state-hover)}",
       ".dsxprx-hdr .dsxprx-dot{width:8px;height:8px}",
@@ -296,26 +302,29 @@ window.__ModuleLoader__.load({
           });
         };
       }
-      var diagUseProxy = useState(true);
-      var setDiagUseProxy = diagUseProxy[1];
-      /** Three-state headline for one probe verdict (usable / degraded / unusable). */
-      function probeHeadline(probe) {
-        if (!probe) return "未知";
-        if (probe.verdict === "usable") return "可用" + (probe.status === undefined ? "" : "（HTTP " + probe.status + "）");
-        if (probe.verdict === "degraded") return "降级：" + (probe.short || "未知");
-        if (probe.verdict === "unusable") return "不可用：" + (probe.short || "未知");
-        return probe.ok ? "可用" : (probe.short || "未知");
-      }
+      // 诊断双通道并行（走代理 + 直连），由 host 一次给出两侧徽章和推荐，
+      // 不再让用户手动勾选通道（2026-09-18：单侧探针分不清被拒者是谁）
       function runDiag() {
         var target = diagUrl.trim();
         if (!target) return;
         setDiagBusy(true);
         setDiagResult(null);
-        fetchJson("/route?url=" + encodeURIComponent(target) + "&useProxy=" + (diagUseProxy[0] ? "1" : "0")).then(function (data) {
+        fetchJson("/route?url=" + encodeURIComponent(target)).then(function (data) {
           setDiagResult(data === null ? { error: "诊断接口不可用" } : data);
         }).finally(function () { setDiagBusy(false); });
       }
       var diag = diagResult[0];
+      /** 通道徽章：优先用 host 的 proxyBadge/directBadge（人话+色），缺失时回退旧判定。 */
+      function channelBadge(name) {
+        var b = diag && typeof diag[name] === "object" && diag[name] !== null ? diag[name] : null;
+        if (b && b.text && b.tone) return b;
+        var fallback = name === "proxyBadge" ? diag?.proxy : diag?.direct;
+        if (!fallback) return { text: "未知", tone: "warn" };
+        if (fallback.verdict === "usable") return { text: "链路通 · 目标正常响应", tone: "ok" };
+        if (fallback.verdict === "degraded") return { text: "链路通 · 这次请求被目标拒绝", tone: "warn" };
+        if (fallback.verdict === "unusable") return { text: "链路不通 · 网络/代理问题", tone: "bad" };
+        return fallback.ok ? { text: "链路通", tone: "ok" } : { text: "链路不通", tone: "bad" };
+      }
 
       return react.createElement("div", { className: "dsxprx", "data-proxy-settings": true },
 
@@ -402,27 +411,29 @@ window.__ModuleLoader__.load({
               onChange: function (event) { setDiagUrl(event.target.value); },
               onKeyDown: function (event) { if (event.key === "Enter") runDiag(); },
             }),
-            react.createElement("label", { className: "dsxprx-diagcheck" },
-              react.createElement("input", {
-                type: "checkbox",
-                checked: diagUseProxy[0],
-                onChange: function (event) { setDiagUseProxy(event.target.checked); },
-              }),
-              "使用代理"),
             react.createElement("button", { type: "button", className: "dsxprx-diagbtn", onClick: runDiag, disabled: diagBusy[0] || !diagUrl.trim() }, "测试路由")
           ),
-          react.createElement("span", { className: "dsxprx-hint" }, "勾选「使用代理」= 强制走代理测通不通；不勾 = 强制直连测。对比可判断该域名该不该加进 NO_PROXY。"),
+          react.createElement("span", { className: "dsxprx-hint" }, "同时测「走代理」与「直连」两条通道并给出推荐，可判断该域名该不该加进 NO_PROXY。"),
           diag !== null
             ? react.createElement("div", { className: "dsxprx-diagout" },
               diag.error
                 ? react.createElement("span", null, "诊断失败：" + diag.error)
                 : [
-                  react.createElement("span", { key: "c" }, "测试通道： " + (diag.channel === "proxy" ? "经代理（强制）" : diag.channel === "direct" ? "直连（强制绕过）" : "按当前策略")),
                   react.createElement("span", { key: "r" }, "策略判定： " + diag.route + (diag.bypassed ? "（NO_PROXY 命中）" : "")),
-                  react.createElement("span", { key: "p" }, "连通探测： " + probeHeadline(diag.probe)),
-                  diag.probe && diag.probe.why ? react.createElement("span", { key: "w", className: "dsxprx-diagwhy" }, "可能原因： " + diag.probe.why) : null,
-                  diag.probe && diag.probe.fix ? react.createElement("span", { key: "f", className: "dsxprx-diagfix" }, "挽救措施： " + diag.probe.fix) : null,
-                  diag.probe && diag.probe.note ? react.createElement("span", { key: "n", className: "dsxprx-diagnote" }, "备注： " + diag.probe.note) : null,
+                  react.createElement("span", { key: "px", className: "dsxprx-diagprobe" },
+                    react.createElement("span", { className: "dsxprx-diotag" }, "走代理"),
+                    react.createElement("span", { className: "dsxprx-verdict", "data-tone": channelBadge("proxyBadge").tone }, channelBadge("proxyBadge").text)
+                  ),
+                  react.createElement("span", { key: "dx", className: "dsxprx-diagprobe" },
+                    react.createElement("span", { className: "dsxprx-diotag" }, "直连"),
+                    react.createElement("span", { className: "dsxprx-verdict", "data-tone": channelBadge("directBadge").tone }, channelBadge("directBadge").text)
+                  ),
+                  diag.verdict ? react.createElement("span", { key: "v", className: "dsxprx-diagverdict" },
+                    react.createElement("span", { className: "dsxprx-verdictlarge" }, "推荐： " + (diag.short || "未知")),
+                    diag.why ? react.createElement("span", { className: "dsxprx-diagwhy" }, "可能原因： " + diag.why) : null,
+                    diag.fix ? react.createElement("span", { className: "dsxprx-diagfix" }, "挽救措施： " + diag.fix) : null
+                  ) : null,
+                  diag.proxy && diag.proxy.note ? react.createElement("span", { key: "n", className: "dsxprx-diagnote" }, "备注： " + diag.proxy.note) : null,
                   diag.hint ? react.createElement("span", { key: "h" }, "提示： " + diag.hint) : null,
                 ]
             )

package/lib/index.js

@@ -32,6 +32,8 @@ import { promisify } from 'node:util'
 import {
   classifyProbeStatus,
   classifyTargetFailure,
+  combineDualProbe,
+  headNeedsGetRetry,
   keepaliveHint,
   makeSystemProxyReader,
   normalizeProxyUrl,
@@ -171,10 +173,12 @@ const PROBE_UA = 'dsh-proxy-pro/0.1'
 const PROBE_TIMEOUT_MS = 6000
 
 /**
- * 一个探测尝试：先 HEAD，端点不支持 HEAD（405/501）时再用 GET 复测——
- * 很多 API 只实现 GET，只用 HEAD 会冤枉一个可用主机。`request` 是调用方
- * 的 fetch：两条通道现在都用 app undici 的 `und.fetch` 配同副本 dispatcher
- * （LESSONS §22/§25 —— 绝不要把两份副本混在一起）。
+ * 一个探测尝试：先 HEAD，HEAD 结论不可信（404/405/501）时再用 GET 复测——
+ * 405/501 是「不支持该方法」，404 是网关不给 HEAD 注册路由时的伪装
+ * （LESSONS §27：DashScope `HEAD /models` → 404，同路径 GET → 401），只用
+ * HEAD 会把健康端点误判成「路径不存在」。`request` 是调用方的 fetch：两条
+ * 通道都用 app undici 的 `und.fetch` 配同副本 dispatcher（LESSONS §22/§25
+ * —— 绝不要把两份副本混在一起）。
  *
  * @returns classifyProbeStatus / classifyTargetFailure 的判定。
  */
@@ -197,13 +201,16 @@ async function probeHttp(request, target, dispatcher) {
   const head = await attempt('HEAD')
   if (head.error !== undefined) return classifyTargetFailure(head.error)
   const verdict = classifyProbeStatus(head.res.status)
-  if (verdict.kind !== 'http-error' || (head.res.status !== 405 && head.res.status !== 501)) return verdict
+  if (verdict.kind !== 'http-error' || !headNeedsGetRetry(head.res.status)) return verdict
   const get = await attempt('GET')
   if (get.error !== undefined) return classifyTargetFailure(get.error)
   const retried = classifyProbeStatus(get.res.status)
-  retried.note = retried.ok === true
-    ? 'HEAD 被拒绝但 GET 可用 — 主机可用。'
-    : 'HEAD 被拒绝；GET 复测也遇到同类问题。'
+  const sameStatus = get.res.status === head.res.status
+  retried.note = sameStatus
+    ? `HEAD 与 GET 均返回 ${get.res.status} — 该路径确实不可用。`
+    : retried.ok === true
+      ? `HEAD 返回 ${head.res.status}，GET 得到 ${get.res.status} — 以 GET 为准（网关常不给 HEAD 注册路由）。`
+      : `HEAD 返回 ${head.res.status}，GET 得到 ${get.res.status} — 以 GET 为准。`
   return retried
 }
 
@@ -261,18 +268,25 @@ async function policyProbe(target) {
 }
 
 /**
- * 按 web_fetch 的方式探测一个目标：先给路由判定，再用策略通道发真实请求
- * （app undici 的 fetch + 全局 dispatcher，见 policyProbe）。`channel` 选择
- * 探测路径：'policy'（默认）、'proxy'（强制走代理）、'direct'（强制绕过）。
+ * 按 web_fetch 的方式探测一个目标，**同时**强制走代理 + 强制直连两个通道，
+ * 再把两侧结果综合成一条人话推荐（combineDualProbe）。
+ *
+ * 单侧探测无法判断被拒是谁干的（目标 or 代理?）——只有两侧对比才能得出
+ * 方向性结论（直连通+代理失败 → 问题在代理一侧；代理通+直连失败 → 代理是
+ * 唯一通路）。`channel` 保留兼容：'policy'/'proxy'/'direct' 仍是旧的单通道
+ * 探测（HTTP API 的历史 useProxy 参数使用），默认 'dual' 走双通道并行。
  */
-async function probeTarget(url, snapshot, channel = 'policy') {
+async function probeTarget(url, snapshot, channel = 'dual') {
   let parsed
   try {
     parsed = new URL(url)
   } catch {
-    return { url, route: 'invalid', bypassed: false,
-      probe: { ok: false, verdict: 'unusable', kind: 'invalid', short: 'URL 无效 — 需要 http(s)://主机/路径',
-        why: '输入不是可解析的绝对 URL。', fix: '用完整形式，如 https://github.com/foo/bar。' } }
+    return { url, route: 'invalid', bypassed: false, channel,
+      proxy: { ok: false, verdict: 'unusable', kind: 'invalid', short: 'URL 无效 — 需要 http(s)://主机/路径',
+        why: '输入不是可解析的绝对 URL。', fix: '用完整形式，如 https://github.com/foo/bar。' },
+      direct: { ok: false, verdict: 'unusable', kind: 'invalid', short: 'URL 无效 — 需要 http(s)://主机/路径',
+        why: '输入不是可解析的绝对 URL。', fix: '用完整形式，如 https://github.com/foo/bar。' },
+      verdict: 'both-bad', short: 'URL 无效', why: '输入不是可解析的绝对 URL。', fix: '用完整形式，如 https://github.com/foo/bar。' }
   }
   let routeName = 'DIRECT'
   try {
@@ -286,6 +300,8 @@ async function probeTarget(url, snapshot, channel = 'policy') {
     const host = entry.trim().replace(/^\*?\./, '').toLowerCase()
     return host.length > 0 && (host === parsed.hostname.toLowerCase() || parsed.hostname.toLowerCase().endsWith(`.${host}`))
   })
+
+  // 兼容旧单通道调用（HTTP API 历史 useProxy 参数）
   if (channel === 'proxy' || channel === 'direct') {
     const proxyUrl = channel === 'proxy' ? (snapshot?.effective?.url ?? '') : ''
     const probe = proxyUrl === '' && channel === 'proxy'
@@ -295,8 +311,27 @@ async function probeTarget(url, snapshot, channel = 'policy') {
       : await forceChannelProbe(parsed, channel, proxyUrl)
     return { url, route: routeName, bypassed, channel, probe }
   }
-  const probe = await policyProbe(parsed)
-  return { url, route: routeName, bypassed, probe }
+  if (channel === 'policy') {
+    const probe = await policyProbe(parsed)
+    return { url, route: routeName, bypassed, channel, probe }
+  }
+
+  // 双通道并行：强制走代理 + 强制直连，各自独立探测（互不干扰）
+  const proxyUrl = snapshot?.effective?.url ?? ''
+  const proxyProbe = proxyUrl === ''
+    ? { ok: false, verdict: 'unusable', kind: 'bad-proxy', short: '当前快照里没有可用的代理地址',
+      why: '代理开关处于关闭（或 Windows 系统代理关闭），没有可强制走代理的对象。',
+      fix: '打开代理，或在「代理配置」里修复地址/模式。' }
+    : await forceChannelProbe(parsed, 'proxy', proxyUrl)
+  const directProbe = await forceChannelProbe(parsed, 'direct', '')
+  const combined = combineDualProbe(proxyProbe, directProbe)
+  return {
+    url, route: routeName, bypassed, channel: 'dual',
+    proxy: proxyProbe, direct: directProbe,
+    verdict: combined.verdict, short: combined.short,
+    why: combined.why, fix: combined.fix,
+    proxyBadge: combined.proxyBadge, directBadge: combined.directBadge,
+  }
 }
 
 // ---- browser-trust fence (mirrors dsh's /api fence) ------------------------
@@ -526,18 +561,16 @@ function apply(ctx, config) {
     output: {
       schema: PROXY_TEST_SCHEMA,
       render: (_args, value) => {
-        const p = value.probe ?? {}
-        const head = p.verdict === 'usable'
-          ? `可用${p.status === undefined ? '' : `（HTTP ${p.status}）`}`
-          : `${p.verdict === 'degraded' ? '降级' : '不可用'} — ${p.short ?? '未知'}`
+        const badge = (b) => (b?.tone === 'ok' ? '🟢' : b?.tone === 'warn' ? '🟡' : '🔴') + ' ' + (b?.text ?? '未知')
         const lines = [
           `路由: ${value.route}`,
           `NO_PROXY 命中: ${value.bypassed}`,
-          `连通探测: ${head}`,
+          `走代理: ${badge(value.proxyBadge)}`,
+          `直连:   ${badge(value.directBadge)}`,
+          `结论: ${value.short ?? '未知'}`,
         ]
-        if (p.why) lines.push(`可能原因: ${p.why}`)
-        if (p.fix) lines.push(`挽救措施: ${p.fix}`)
-        if (p.note) lines.push(`备注: ${p.note}`)
+        if (value.why) lines.push(`可能原因: ${value.why}`)
+        if (value.fix) lines.push(`挽救措施: ${value.fix}`)
         if (value.hint) lines.push(`提示: ${value.hint}`)
         return [{ type: 'text', text: lines.join('\n') }]
       },
@@ -545,7 +578,7 @@ function apply(ctx, config) {
     execute: async (args) => {
       await requestSync()
       const result = await probeTarget(String(args.url ?? ''), snapshot)
-      result.hint = keepaliveHint(result.probe?.short ?? '', snapshot?.effective?.url ?? '')
+      result.hint = keepaliveHint(`${result.proxy?.short ?? ''} ${result.direct?.short ?? ''}`, snapshot?.effective?.url ?? '')
       return result
     },
     presentCall: (args) => ({
@@ -662,10 +695,14 @@ function apply(ctx, config) {
             }
             if (is('/route', 'GET')) {
               const target = url.searchParams.get('url') ?? ''
+              // useProxy 保留兼容：'1'/'0' 走旧的单通道强制；无参数（新版面板）走双通道
               const useProxy = url.searchParams.get('useProxy')
-              const channel = useProxy === '1' ? 'proxy' : useProxy === '0' ? 'direct' : 'policy'
+              const channel = useProxy === '1' ? 'proxy' : useProxy === '0' ? 'direct' : 'dual'
               const result = await probeTarget(target, snapshot, channel)
-              result.hint = keepaliveHint(result.probe?.short ?? '', snapshot?.effective?.url ?? '')
+              result.hint = keepaliveHint(
+                `${result.proxy?.short ?? ''} ${result.direct?.short ?? ''}`.trim(),
+                snapshot?.effective?.url ?? ''
+              )
               sendJson(res, 200, { ok: true, ...result })
               return
             }

package/lib/proxy-core.js

@@ -282,6 +282,23 @@ export function keepaliveHint(message = '', proxyUrl = '') {
  * @param status - 探测收到的 HTTP 状态码。
  * @returns `{ ok, verdict, kind, status, short, why, fix }`（中文文案）。
  */
+/**
+ * HEAD 结论不可信、必须换 GET 复测的状态码。
+ *
+ * 405/501 是服务器明说「不支持该方法」；**404 同样是陷阱**：很多网关不给
+ * HEAD 注册路由，对 HEAD 一律回 404，而同一路径 GET 会正常回 401/200 ——
+ * 实测 DashScope：`HEAD /compatible-mode/v1/models` → 404，同路径 GET → 401
+ * （2026-09-18 用户报「测什么都 404」时定位）。不复测就会把健康端点误判成
+ * 「路径不存在」。
+ *
+ * @param status - HEAD 探测收到的状态码。
+ * @returns 是否需要用 GET 复测。
+ */
+export function headNeedsGetRetry(status) {
+  const code = Number(status)
+  return code === 404 || code === 405 || code === 501
+}
+
 export function classifyProbeStatus(status) {
   const code = Number(status)
   const base = { status: code }
@@ -305,8 +322,8 @@ export function classifyProbeStatus(status) {
   }
   if (code === 404) {
     return { ...base, ok: false, verdict: 'degraded', kind: 'http-error', short: 'HTTP 404 — 路径不存在',
-      why: '路由已到服务器，但该路径不存在（探测常打根路径）。',
-      fix: '用真实调用的完整路径复测；能通就忽略此结果。' }
+      why: 'HEAD 与 GET 都拿到了 404：路由已到服务器，但该路径确实没有资源（探测常打根路径或裸前缀）。',
+      fix: '改用真实调用的完整端点复测（如 .../models、.../chat/completions）；那里有响应就说明主机可用。' }
   }
   if (code === 405 || code === 501) {
     return { ...base, ok: false, verdict: 'degraded', kind: 'http-error', short: `HTTP ${code} — 端点不支持 HEAD`,
@@ -399,3 +416,82 @@ export function classifyTargetFailure(error) {
     why: '请求失败，探测器无法归类原因。',
     fix: '对比直连/代理两侧并重试；用 proxy_status 查看生效路由。' }
 }
+
+/**
+ * 双通道综合判定：把「强制走代理」与「强制直连」两次探测合成为一份可给人
+ * 看的结果：两条徽章（各自带 tone 色）+ 一条推荐。
+ *
+ * 单侧探针拿不到应答者身份，因此「代理策略拦截」只能靠两侧对比得到方向性
+ * 结论（LESSONS §30：直连通+代理失败 → 问题在代理一侧；代理通+直连失败 →
+ * 代理是唯一通路；都失败 → 环境/服务端问题；都通 → 保持现状）。
+ *
+ * @param proxyProbe - 强制走代理通道的探测结果（classify 输出形态）。
+ * @param directProbe - 强制直连通道的探测结果。
+ * @returns `{ verdict, short, why, fix, proxyBadge, directBadge }`，
+ *   badge = { text, tone: 'ok'|'warn'|'bad' }。
+ */
+export function combineDualProbe(proxyProbe, directProbe) {
+  const proxyOk = proxyProbe?.ok === true
+  const directOk = directProbe?.ok === true
+  const proxyAuth = proxyProbe?.kind === 'auth'
+    || (proxyProbe?.verdict === 'unusable' && /NTLM|407/.test(String(proxyProbe?.short ?? '')))
+
+  const notReachable = (probe, label) => {
+    const detail = (probe?.short ?? '未知原因').replace(/^HTTP \d+ — /, '')
+    return `${label}：${detail}`
+  }
+
+  // 都通 → 都可以
+  if (proxyOk && directOk) {
+    return {
+      verdict: 'both-ok',
+      short: '代理与直连均通',
+      why: '两条通道都拿到了正常应答，目标本身可用。',
+      fix: '保持当前策略即可；无需改 NO_PROXY。',
+      proxyBadge: { text: '链路通 · 目标正常响应', tone: 'ok' },
+      directBadge: { text: '链路通 · 目标正常响应', tone: 'ok' },
+    }
+  }
+
+  // 只有代理通 → 走代理
+  if (proxyOk && !directOk) {
+    return {
+      verdict: 'proxy-only',
+      short: '只有走代理能通',
+      why: `直连 ${notReachable(directProbe, '失败')}；走代理正常——该目标在当前网络需经代理访问。`,
+      fix: '确认该域名不在 NO_PROXY 直连名单里；保持代理开启。',
+      proxyBadge: { text: '链路通 · 目标正常响应', tone: 'ok' },
+      directBadge: { text: '链路不通 · 直连失败', tone: 'bad' },
+    }
+  }
+
+  // 只有直连通 → 问题在代理一侧（可能是策略拦截/认证/代理故障）
+  if (!proxyOk && directOk) {
+    const base = proxyAuth
+      ? {
+          why: '代理要求 NTLM 认证（407），而直连正常——该目标不值得绕代理。',
+          fix: '该域名走代理会被认证卡住：把它加入 NO_PROXY 直连名单即可；无需打开认证窗口。',
+        }
+      : {
+          why: '经代理失败而直连正常——问题最可能在代理一侧：访问策略拦截、代理故障，或代理到目标之间的链路异常。',
+          fix: '先重试排除临时故障；仍失败则检查代理可用性或联系管理员。若确认是策略拦截，把该域名加入 NO_PROXY 直连名单。',
+        }
+    return {
+      verdict: proxyAuth ? 'direct-only-auth' : 'direct-only',
+      short: proxyAuth ? '直连可通 · 代理需认证' : '直连可通 · 代理被拦',
+      ...base,
+      proxyBadge: { text: proxyAuth ? '链路不通 · 代理要求认证' : '链路不通 · 经代理访问失败', tone: 'bad' },
+      directBadge: { text: '链路通 · 目标正常响应', tone: 'ok' },
+    }
+  }
+
+  // 都失败 → 环境/服务端问题
+  return {
+    verdict: 'both-bad',
+    short: '代理与直连均失败',
+    why: `两条通道都没拿到正常应答：代理 ${notReachable(proxyProbe, '失败')}；直连 ${notReachable(directProbe, '失败')}。`,
+    fix: '是环境或服务端问题，与代理开关无关：检查网络/目标服务，或稍后重试。',
+    proxyBadge: { text: `链路不通 · ${notReachable(proxyProbe, '代理失败')}`, tone: 'bad' },
+    directBadge: { text: `链路不通 · ${notReachable(directProbe, '直连失败')}`, tone: 'bad' },
+  }
+}

package/lib/tool-schemas.js

@@ -54,7 +54,28 @@ export const PROXY_TEST_PARAMETERS = {
   },
 }
 
-/** Output schema of `proxy_test`. */
+/** Reusable per-channel probe result (a classifyProbeStatus / classifyTargetFailure
+ *  output). Schema DSL has no $ref, so this inlines into PROXY_TEST_SCHEMA. */
+const PROBE_RESULT_SCHEMA = {
+  type: 'object',
+  additionalProperties: false,
+  required: true,
+  properties: {
+    ok: { type: 'boolean', required: true },
+    verdict: { type: 'string' },
+    status: { type: 'number' },
+    kind: { type: 'string' },
+    short: { type: 'string' },
+    why: { type: 'string' },
+    fix: { type: 'string' },
+    note: { type: 'string' },
+  },
+}
+
+/** Output schema of `proxy_test`. Dual-channel: forces both legs in parallel
+ * (走代理 / 直连), then combines them into one human verdict + recommendation
+ * (2026-09-18: single-side probes cannot tell WHO answered, so a strategy
+ * block can only be inferred by comparing both sides — LESSONS §30). */
 export const PROXY_TEST_SCHEMA = {
   type: 'object',
   additionalProperties: false,
@@ -62,25 +83,13 @@ export const PROXY_TEST_SCHEMA = {
     url: { type: 'string', required: true },
     route: { type: 'string', required: true },
     bypassed: { type: 'boolean', required: true },
-    probe: {
-      type: 'object',
-      additionalProperties: false,
-      required: true,
-      properties: {
-        ok: { type: 'boolean', required: true },
-        // Three-state verdict plus the actionable pair the panel and the tool
-        // render (2026-09-17: a 504 used to print as "reachable"). Every field
-        // must be listed here — the object is additionalProperties:false, so an
-        // undeclared field fails schema validation.
-        verdict: { type: 'string' },
-        status: { type: 'number' },
-        kind: { type: 'string' },
-        short: { type: 'string' },
-        why: { type: 'string' },
-        fix: { type: 'string' },
-        note: { type: 'string' },
-      },
-    },
+    channel: { type: 'string', required: true },
+    proxy: PROBE_RESULT_SCHEMA,
+    direct: PROBE_RESULT_SCHEMA,
+    verdict: { type: 'string', required: true },
+    short: { type: 'string', required: true },
+    why: { type: 'string', required: true },
+    fix: { type: 'string', required: true },
     hint: { type: 'string' },
   },
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yanglaofish/dsh-proxy-pro",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "DSH proxy manager: route model requests, web fetches and spawned tools through the Windows system proxy or a custom address; per-URL route diagnosis, one-click toggle from the conversation header, a dedicated Settings page, and keepalive-aware 407 hints.",
   "type": "module",
   "main": "./lib/index.js",