@yanglaofish/dsh-proxy-pro 1.0.7 → 1.0.9

package/docs/LESSONS.md

@@ -780,4 +780,38 @@ API 端点就这样被误判。**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/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,31 @@ 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" };
+        // 5xx：拿到了 HTTP 应答，链路通但服务端/网关报错（严重性误导修复：不算"链路不通"）
+        if (fallback.kind === "gateway" || fallback.kind === "server-error") return { text: "链路通 · 目标/网关报错", tone: "warn" };
+        if (fallback.unusable === true || 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 +413,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,7 @@ import { promisify } from 'node:util'
 import {
   classifyProbeStatus,
   classifyTargetFailure,
+  combineDualProbe,
   headNeedsGetRetry,
   keepaliveHint,
   makeSystemProxyReader,
@@ -267,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 {
@@ -292,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'
@@ -301,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) ------------------------
@@ -532,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') }]
       },
@@ -551,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) => ({
@@ -668,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

@@ -416,3 +416,172 @@ export function classifyTargetFailure(error) {
     why: '请求失败，探测器无法归类原因。',
     fix: '对比直连/代理两侧并重试；用 proxy_status 查看生效路由。' }
 }
+
+/**
+ * 单侧通道的徽章：按真实语义给色，杜绝"严重性误导"（LESSONS §32）。
+ * - usable（2xx/3xx/401）→ 🟢 链路通 · 目标正常响应
+ * - degraded（403/404/405/429 等被目标拒绝）→ 🟡 链路通 · 目标拒绝（…）
+ * - 5xx（500/502/503/504 拿到应答但目标/网关报错）→ 🟡 链路通 · 目标/网关报错（…）
+ * - 407 认证拦截 → 🔴 链路不通 · 代理要求认证
+ * - 其他不可达（DNS/拒绝/超时/本地错误）→ 🔴 链路不通 · …
+ * 关键区分：**只要拿到了 HTTP 应答（含 4xx/5xx）链路就是通的**，只有
+ * 连接层失败（未拿到应答）才是"链路不通"。404 曾因 ok=false 被误标红色
+ * 链路不通 → 截图"代理与直连均失败"误导（2026-09-18 用户实况）。
+ */
+function dualBadge(probe) {
+  const detail = (s) => String(s ?? '').replace(/^HTTP \d+ — /, '')
+  if (!probe) return { text: '结果未知', tone: 'warn' }
+  if (probe.verdict === 'usable') return { text: '链路通 · 目标正常响应', tone: 'ok' }
+  if (probe.verdict === 'degraded') {
+    return { text: `链路通 · 目标拒绝（${detail(probe.short) || '请求被拒'}）`, tone: 'warn' }
+  }
+  if (probe.kind === 'gateway' || probe.kind === 'server-error') {
+    return { text: `链路通 · 目标/网关报错（${detail(probe.short) || String(probe.status ?? '5xx')}）`, tone: 'warn' }
+  }
+  if (probe.kind === 'auth') return { text: '链路不通 · 代理要求认证', tone: 'bad' }
+  return { text: `链路不通 · ${detail(probe.short) || '连接失败'}`, tone: 'bad' }
+}
+
+/**
+ * 双通道综合判定：把「强制走代理」与「强制直连」两次探测合成为一份可给人
+ * 看的结果：两条徽章（各自带 tone 色）+ 一条推荐。
+ *
+ * 三个概念分离（LESSONS §32 严重性误导修复）：
+ * - 可达（reachable）：通道真正拿到了目标应答——usable 或 degraded（4xx）。
+ *   5xx 属"链路通但目标/网关报错"（kind=gateway/server-error），不算可达
+ *   也不算不通，徽章黄色；407/连接层失败才是"不通"。
+ * - 健康（healthy）：usbale，目标给了正常应答。
+ * - 徽章：由 dualBadge 按实际 verdict/kind 生成，绝不把 404/403 标红。
+ *   只有连接层失败才标红"链路不通"。
+ *
+ * 单侧探针拿不到应答者身份，因此「代理策略拦截」只能靠两侧对比得到方向性
+ * 结论（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 p = proxyProbe ?? {}
+  const d = directProbe ?? {}
+  const pReach = p.verdict === 'usable' || p.verdict === 'degraded'
+  const dReach = d.verdict === 'usable' || d.verdict === 'degraded'
+  const pOk = p.verdict === 'usable'
+  const dOk = d.verdict === 'usable'
+  const proxyAuth = p.kind === 'auth'
+    || (p.verdict === 'unusable' && /NTLM|407/.test(String(p.short ?? '')))
+
+  const notReachable = (probe, label) => {
+    const detail = (probe?.short ?? '未知原因').replace(/^HTTP \d+ — /, '')
+    return `${label}：${detail}`
+  }
+
+  // ① 都健康 → 都可以（保持现状）
+  if (pOk && dOk) {
+    return {
+      verdict: 'both-ok',
+      short: '代理与直连均通',
+      why: '两条通道都拿到了正常应答，目标本身可用。',
+      fix: '保持当前策略即可；无需改 NO_PROXY。',
+      proxyBadge: { text: '链路通 · 目标正常响应', tone: 'ok' },
+      directBadge: { text: '链路通 · 目标正常响应', tone: 'ok' },
+    }
+  }
+
+  // ② 只有代理健康 → 走代理
+  if (pOk && !dOk) {
+    return {
+      verdict: 'proxy-only',
+      short: '只有走代理能通',
+      why: `直连 ${notReachable(d, '失败')}；走代理正常——该目标在当前网络需经代理访问。`,
+      fix: '确认该域名不在 NO_PROXY 直连名单里；保持代理开启。',
+      proxyBadge: { text: '链路通 · 目标正常响应', tone: 'ok' },
+      directBadge: dualBadge(d),
+    }
+  }
+
+  // ③ 只有直连健康 → 问题在代理一侧（认证拦截 / 不可达 / 被目标拒绝）
+  if (!pOk && dOk) {
+    const pSide = proxyAuth
+      ? '代理要求 NTLM 认证（407），请求没到目标'
+      : p.verdict === 'degraded'
+        ? '经代理已到达目标，但目标拒绝了这次请求（403/404/429 等）'
+        : '经代理未能连接目标（可能是代理策略拦截、代理故障或链路异常）'
+    const base = proxyAuth
+      ? {
+          why: '代理要求 NTLM 认证（407），而直连正常——该目标不值得绕代理。',
+          fix: '该域名走代理会被认证卡住：把它加入 NO_PROXY 直连名单即可；无需打开认证窗口。',
+        }
+      : {
+          why: `${pSide}；而直连正常——结论：该域名走直连更可靠。`,
+          fix: p.verdict === 'degraded'
+            ? '把该域名加入 NO_PROXY 直连名单即可绕开代理侧的目标拒绝；若确需走代理，检查 key/UA/权限。'
+            : '先重试排除临时故障；仍失败则检查代理可用性或联系管理员。若确认是策略拦截，把该域名加入 NO_PROXY 直连名单。',
+        }
+    return {
+      verdict: proxyAuth ? 'direct-only-auth' : 'direct-only',
+      short: proxyAuth ? '直连可通 · 代理需认证' : (p.verdict === 'degraded' ? '直连可通 · 代理侧被目标拒绝' : '直连可通 · 代理被拦'),
+      ...base,
+      proxyBadge: dualBadge(p),
+      directBadge: { text: '链路通 · 目标正常响应', tone: 'ok' },
+    }
+  }
+
+  // ④ 都不健康但都可达（双 4xx：链路通，目标对探测路径有异常应答）
+  if (pReach && dReach) {
+    const pNote = notReachable(p, '代理').replace(/^失败：/, '代理：')
+    const dNote = notReachable(d, '直连').replace(/^失败：/, '直连：')
+    return {
+      verdict: 'both-reached',
+      short: '双链路通 · 目标应答异常',
+      why: `两条通道都到达了目标，但目标返回异常状态：${pNote}；${dNote}。`,
+      fix: '探测的是根路径/裸前缀，目标可能对 HEAD 或未授权请求如此应答——改用真实调用端点（如 /models、/chat/completions）复测，或检查该主机的 API Key。',
+      proxyBadge: dualBadge(p),
+      directBadge: dualBadge(d),
+    }
+  }
+
+  // ⑤ 只有代理可达（哪怕 404/403，也是唯一通路）——修复重点：
+  //    404 不再落入"双失败"，恢复为代理是唯一通路（腾讯 Copilot 实况）
+  if (pReach && !dReach) {
+    const pNote = p.verdict === 'usable' ? '正常响应' : notReachable(p, '请求被拒').replace(/^请求被拒：/, '')
+    return {
+      verdict: 'proxy-only',
+      short: p.verdict === 'usable' ? '只有走代理能通' : '只有走代理可达 · 目标有异常应答',
+      why: `直连 ${notReachable(d, '失败')}；经代理 ${pNote}——该域名在当前网络只有代理通道能到达目标。`,
+      fix: p.verdict === 'usable'
+        ? '确认该域名不在 NO_PROXY 直连名单里；保持代理开启。'
+        : '走代理链路是通的，但目标返回异常（尝试换真实端点复测）；同时确认该域名不在 NO_PROXY 直连名单里。',
+      proxyBadge: dualBadge(p),
+      directBadge: dualBadge(d),
+    }
+  }
+
+  // ⑥ 只有直连可达（代理侧 4xx/5xx 或不可达）
+  if (dReach) {
+    return {
+      verdict: proxyAuth ? 'direct-only-auth' : 'direct-only',
+      short: proxyAuth ? '直连可达 · 代理需认证' : (d.verdict === 'usable' ? '直连可通 · 代理被拦' : '直连可达 · 代理侧异常'),
+      why: proxyAuth
+        ? '代理要求 NTLM 认证（407），而直连正常——该目标不值得绕代理。'
+        : `经代理 ${p.kind === 'gateway' || p.kind === 'server-error' ? '返回网关/服务端错误（链路本身通，问题在目标或中间网关）' : `失败（${notReachable(p, '').replace(/^：/, '')}）`}；直连 ${dOk ? '正常' : notReachable(d, '可达但目标异常')}。`,
+      fix: proxyAuth
+        ? '把该域名加入 NO_PROXY 直连名单即可。'
+        : '建议该域名走直连（加入 NO_PROXY）；若代理侧是 4xx/5xx，也检查一下真实调用端点。',
+      proxyBadge: dualBadge(p),
+      directBadge: dualBadge(d),
+    }
+  }
+
+  // ⑦ 都不可达（连接层失败）→ 环境/服务端问题
+  return {
+    verdict: 'both-bad',
+    short: '代理与直连均失败',
+    why: `两条通道都没能建立到目标的连接：代理 ${notReachable(p, '失败')}；直连 ${notReachable(d, '失败')}。`,
+    fix: '是环境或服务端问题，与代理开关无关：检查网络/目标服务，或稍后重试。',
+    proxyBadge: dualBadge(p),
+    directBadge: dualBadge(d),
+  }
+}

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.7",
+  "version": "1.0.9",
   "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",