dsh-auto-check 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 YanMo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,103 @@
-# Temporary Holding Version
+# dsh-auto-check
+
+为 DeepSeek Harness 的「自动审查」（Auto review）单独指定审查模型。
+
+自动审查默认跟随当前会话的主模型。主模型如果是价格较高的模型，每次工具调用前的审查都会消耗同样的高价 Token。本插件在 `llm/stream` 层拦截自动审查请求，把它改写到单独配置的 provider / model，其余请求原样放行。
+
+## 工作方式
+
+- 自动审查请求的 `system` 提示以 `REVIEW_POLICY\n` 开头，这是插件识别它的唯一稳定标记。
+- 命中后，插件用配置的 provider / model 重新发起一次 LLM 请求；未配置或只配置了一半时，保持原有行为。
+- 改写后的请求会被标记，避免再次进入本插件造成递归。
+- 不替换、不修改自带的 `auto-review` 插件；自动审查的策略、审批和拒绝逻辑全部保持原样。
+
+## 配置
+
+1. 打开 **设置 → 插件**（Plugins）。
+2. 在官方插件列表中找到 **自动审查模型**。
+3. 选择一个审查模型并保存；选择「跟随主模型」可恢复默认行为。
+4. 按需选择「审查协议」：
+   - **自动识别**（默认）：目标模型名包含 `Qwen3Guard` 时使用 Qwen3Guard 适配，否则使用标准 JSON 协议。
+   - **标准 JSON**：要求审查模型严格输出 `{risk, decision, reason?}`，适用于通用模型。
+   - **Qwen3Guard 安全分级**：适用于 Qwen3Guard-Gen 系列（0.6B / 4B / 8B）。
+
+模型列表来自当前会话可路由的模型目录。只影响自动审查，不影响主对话或子代理。
+
+## Qwen3Guard 适配
+
+Qwen3Guard-Gen 原生输出不是 JSON，而是两行文本：
+
+```text
+Safety: Safe | Controversial | Unsafe
+Categories: <分类列表 | None>
+```
+
+本插件在 Qwen3Guard 协议下：
+
+- 去掉 auto review 的 JSON 策略 `system`，只把待审内容作为一条 user 消息发送；
+- 把 `Safe` 映射为低风险放行；
+- 把 `Controversial` 映射为中风险拒绝，`Unsafe` 映射为高风险拒绝，拒绝原因保留分类；
+- 把原生文本流转换为 auto review 期望的「一个 text block + stop」流；
+- 模型没有返回 `Safety:` 标签时按高风险拒绝（fail-closed）。
+
+> Qwen3Guard 只判断内容安全，不判断工具调用的业务正确性；`Safe` 只代表内容没有命中安全分类，不代表这次工具调用一定符合你的意图。
+
+> Qwen3Guard 只支持 Gen 系列的安全分级输出，Stream 系列是逐 token 审核，不适用本适配。`Controversial` 在本插件中映射为中风险拒绝：在 auto review 的默认审批策略下，它可能被转成一次用户确认，而不是直接丢弃；如果审批策略是 `never`，则会直接拒绝。若模型别名不含 `Qwen3Guard`，请在「审查协议」中显式选择 Qwen3Guard。
+
+> 审查模型不可用（例如凭据失效、模型下线）时，自动审查会按原有失败策略拒绝工具调用。换回「跟随主模型」或选择一个可用模型即可恢复。
+
+## 安装
+
+```powershell
+# 在 DSH 中通过插件管理器安装本目录：
+# plugin_manager install_bundle target=<本目录绝对路径>
+```
+
+安装后包会以 `link:` 方式加入 profile。Host 侧代码的模块和 Config schema 会被 Node 缓存，修改 `lib/` 后需要重启 DSH Desktop（Electron）才能重新加载；只刷新页面不会更新 Host 插件。客户端 `client.js` 改动在刷新页面后生效。
+
+## 开发验证
+
+```powershell
+node --test test/review-route.test.mjs
+node --check lib/index.js
+node --check client.js
+```
+
+测试覆盖：普通请求放行、审查请求改写、递归回放、空配置回退、同路由不重复改写、Qwen3Guard 协议探测、请求改写、标签映射与流转换。
+
+## 发布到 npm
+
+仓库包含 `.github/workflows/publish.yml`：推送 `v*` tag 时测试并**暂存**发布到 npm，使用 Trusted Publishing（OIDC），不保存长期 npm token。
+
+首次发布需要手动认领包名：
+
+```powershell
+npm login --registry=https://registry.npmjs.org
+npm publish --registry=https://registry.npmjs.org --access public
+```
+
+然后在 npmjs.com 的包设置 → Trusted Publishing 中添加 GitHub Actions：
+
+- Owner：`ltzXiaoYanMo`
+- Repository：`dsh-auto-check`
+- Workflow：`publish.yml`
+
+之后的发布流程：
+
+```powershell
+git tag v0.1.1
+git push origin v0.1.1
+```
+
+工作流以 `npm stage publish` 把版本放入 npm 暂存区；因为 Trusted Publisher 配置的是 `npm stage publish` 权限，最终发布需要维护者完成 2FA 审批：
+
+```powershell
+npm login --registry=https://registry.npmjs.org
+npm stage list
+npm stage approve <stage-id>
+```
+
+也可以在 npmjs.com 的包页面完成审批。
+
+`dsh-plugins` 是仓库里程碑 tag，不会触发 npm 发布。
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.

package/client.js

@@ -0,0 +1,380 @@
+window.__ModuleLoader__.load({
+  id: "dsh-auto-check",
+  factory: (require) => {
+    const { jsx, jsxs } = require("react/jsx-runtime");
+    const {
+      SettingsForm,
+      SettingsFormModel,
+      settingsTextField,
+    } = require("@deepseek-ai/dsh-client-ui-primitives");
+
+    const NS = "settings.autoCheck";
+    const ENTRY_ID = "dsh-auto-check";
+    const SEP = "\u0000";
+
+    const css =
+      ".dshAutoCheckField{display:grid;gap:6px;padding:12px 0}" +
+      ".dshAutoCheckLabel{color:var(--dsw-alias-label-primary);font-size:13px;line-height:1.5}" +
+      ".dshAutoCheckSelect{background:var(--dsw-alias-bg-layer-1);border:.5px solid var(--dsw-alias-border-l4);border-radius:var(--dsw-radius-md);color:var(--dsw-alias-label-primary);font:inherit;font-size:13px;min-height:32px;padding:4px 8px;width:100%;max-width:520px}" +
+      ".dshAutoCheckSelect:disabled{opacity:.6}" +
+      ".dshAutoCheckHint{margin:0;color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:1.5}" +
+      ".dshAutoCheckNotice{margin:0;color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:1.5}" +
+      ".dshAutoCheckError{display:flex;align-items:center;gap:12px;margin:0;color:var(--dsw-alias-state-error-primary);font-size:12px;line-height:1.5}" +
+      ".dshAutoCheckError button{background:0 0;border:0;color:var(--dsw-alias-brand-primary);cursor:pointer;font:inherit;padding:0}";
+    const tagId = "dsh-auto-check/settings.css";
+    if (
+      typeof document !== "undefined" &&
+      document.querySelector('style[data-plugin-css="' + tagId + '"]') === null
+    ) {
+      const tag = document.createElement("style");
+      tag.dataset.plugin = "dsh-auto-check";
+      tag.dataset.pluginCss = tagId;
+      tag.textContent = css;
+      document.head.appendChild(tag);
+    }
+
+    const zh = {
+      title: "自动审查模型",
+      description: "为自动审查单独选择审查模型，不再跟随主模型。",
+      reviewerModel: "审查模型",
+      followMain: "跟随主模型（默认）",
+      hint: "自动审查的请求会改走这里选择的模型；留空则保持原有行为。只影响自动审查，不影响主对话。",
+      protocol: "审查协议",
+      protocolAuto: "自动识别（模型名含 Qwen3Guard）",
+      protocolJson: "标准 JSON（通用模型）",
+      protocolQwen3Guard: "Qwen3Guard 安全分级",
+      protocolHint: "Qwen3Guard 模式会去掉 auto review 的 JSON 策略，把待审内容作为用户消息发送，并把 Safety 标签映射为风险等级：Safe 放行，Controversial / Unsafe 拒绝。",
+      protocolWarning: "Controversial 按中风险拒绝；默认审批策略下可能转人工确认，审批策略为 never 时直接拒绝。",
+      loading: "正在加载可用模型…",
+      loadFailed: "无法加载模型列表。",
+      retry: "重试",
+      partial: "部分提供商暂不可用，列表可能不完整。",
+      unlisted: "当前配置（不在列表）",
+      empty: "没有可用的模型。",
+      unavailable: "此设置当前不可用。",
+      readOnly: "此设置当前为只读。",
+      saveFailed: "保存失败，请重试。",
+      save: "保存",
+      saving: "保存中…",
+    };
+    const en = {
+      title: "Auto review model",
+      description: "Choose a dedicated reviewer model for Auto review instead of following the main model.",
+      reviewerModel: "Reviewer model",
+      followMain: "Follow the main model (default)",
+      hint: "Auto review requests are routed to this model. Leave it empty to keep the original behaviour. Only Auto review is affected.",
+      protocol: "Review protocol",
+      protocolAuto: "Auto-detect (Qwen3Guard in model name)",
+      protocolJson: "Standard JSON (general models)",
+      protocolQwen3Guard: "Qwen3Guard safety grading",
+      protocolHint: "Qwen3Guard mode removes auto review's JSON policy, sends the pending content as the user message, and maps the Safety label to a risk level: Safe allows; Controversial / Unsafe deny.",
+      protocolWarning: "Controversial is denied as medium risk; the default approval policy may turn it into a user confirmation, while a `never` override denies it outright.",
+      loading: "Loading available models…",
+      loadFailed: "Could not load the model list.",
+      retry: "Retry",
+      partial: "Some providers are unavailable, so the list may be incomplete.",
+      unlisted: "Current setting (not listed)",
+      empty: "No models are available.",
+      unavailable: "This setting is currently unavailable.",
+      readOnly: "This setting is read-only.",
+      saveFailed: "Could not save. Try again.",
+      save: "Save",
+      saving: "Saving…",
+    };
+
+    const labels = (t) => ({
+      unavailable: t("unavailable"),
+      readOnly: t("readOnly"),
+      saveFailed: t("saveFailed"),
+      save: t("save"),
+      saving: t("saving"),
+    });
+
+    class AutoCheckCardController {
+      constructor(ctx, scope) {
+        this.ctx = ctx;
+        this.form = new SettingsFormModel(scope, [
+          settingsTextField("provider"),
+          settingsTextField("model"),
+          settingsTextField("protocol"),
+        ]);
+        this.actions = this.form.actions();
+        this.store = this.form.bind(() => this.projection());
+        this.groups = [];
+        this.catalogStatus = "loading";
+        this.catalogPartial = false;
+        this.generation = 0;
+        void this.refreshCatalog();
+      }
+
+      projection() {
+        return {
+          ...this.form.shell(),
+          provider: this.form.field("provider"),
+          model: this.form.field("model"),
+          protocol: this.form.field("protocol"),
+          groups: this.groups,
+          catalogStatus: this.catalogStatus,
+          catalogPartial: this.catalogPartial,
+        };
+      }
+
+      publish() {
+        this.form.publish();
+      }
+
+      async refreshCatalog() {
+        const generation = ++this.generation;
+        this.catalogStatus = "loading";
+        this.catalogPartial = false;
+        this.publish();
+        try {
+          const response = await this.ctx.remote.session.modelCatalog();
+          if (generation !== this.generation) return;
+          if (response !== undefined && response.ok) {
+            this.groups = response.value.groups;
+            this.catalogPartial = response.value.failures.length > 0;
+            this.catalogStatus = "ready";
+          } else {
+            this.catalogStatus = "error";
+          }
+        } catch {
+          if (generation !== this.generation) return;
+          this.catalogStatus = "error";
+        }
+        this.publish();
+      }
+
+      selectRoute(route) {
+        if (route === null) {
+          this.actions.edit("provider", "");
+          this.actions.edit("model", "");
+          this.actions.edit("protocol", "auto");
+          return;
+        }
+        this.actions.edit("provider", route.provider);
+        this.actions.edit("model", route.model);
+        const protocol = this.form.field("protocol").text.trim().toLowerCase();
+        if (protocol === "qwen3guard" && !/qwen3guard/i.test(route.model)) {
+          this.actions.edit("protocol", "auto");
+        }
+      }
+
+      inject() {
+        return {
+          hooks: { autoCheckCard: this.store },
+          ...this.actions,
+        };
+      }
+
+      dispose() {
+        this.form.dispose();
+      }
+    }
+
+    function AutoCheckCard(props) {
+      const { t } = props;
+      const state = props.useAutoCheckCard((snapshot) => snapshot);
+      if (props.view === "summary") return t("description");
+
+      const provider = state.provider.text.trim();
+      const model = state.model.text.trim();
+      const protocol = state.protocol.text.trim() || "auto";
+      const current = provider !== "" && model !== "" ? provider + SEP + model : "";
+      const routes = new Set();
+      for (const group of state.groups) {
+        for (const item of group.models) routes.add(group.id + SEP + item.id);
+      }
+      const unlisted = current !== "" && !routes.has(current);
+
+      const options = [
+        jsx("option", { value: "", children: t("followMain") }, "__follow_main__"),
+      ];
+      for (const group of state.groups) {
+        options.push(
+          jsxs(
+            "optgroup",
+            {
+              label: group.name,
+              children: group.models.map((item) =>
+                jsx(
+                  "option",
+                  {
+                    value: group.id + SEP + item.id,
+                    children: item.name + " · " + group.name,
+                  },
+                  group.id + SEP + item.id,
+                ),
+              ),
+            },
+            group.id,
+          ),
+        );
+      }
+      if (unlisted) {
+        options.push(
+          jsx(
+            "option",
+            {
+              value: current,
+              children:
+                provider + " / " + model + " (" + t("unlisted") + ")",
+            },
+            "__unlisted__",
+          ),
+        );
+      }
+
+      const onSelect = (event) => {
+        const value = event.target.value;
+        if (value === "") {
+          props.selectRoute(null);
+          return;
+        }
+        const index = value.indexOf(SEP);
+        props.selectRoute({
+          provider: value.slice(0, index),
+          model: value.slice(index + SEP.length),
+        });
+      };
+
+      return jsx(SettingsForm, {
+        labels: labels(t),
+        state,
+        onSave: props.save,
+        onDiscard: props.discard,
+        children: jsxs("div", {
+          children: [
+            jsxs("div", {
+              className: "dshAutoCheckField",
+              children: [
+                jsx("label", {
+                  className: "dshAutoCheckLabel",
+                  htmlFor: "dsh-auto-check-model",
+                  children: t("reviewerModel"),
+                }),
+                jsx("select", {
+                  className: "dshAutoCheckSelect",
+                  id: "dsh-auto-check-model",
+                  value: current,
+                  disabled: !state.writable || state.saving,
+                  onChange: onSelect,
+                  children: options,
+                }),
+              ],
+            }),
+            jsxs("div", {
+              className: "dshAutoCheckField",
+              children: [
+                jsx("label", {
+                  className: "dshAutoCheckLabel",
+                  htmlFor: "dsh-auto-check-protocol",
+                  children: t("protocol"),
+                }),
+                jsx("select", {
+                  className: "dshAutoCheckSelect",
+                  id: "dsh-auto-check-protocol",
+                  value: protocol,
+                  disabled: !state.writable || state.saving,
+                  onChange: (event) => props.edit("protocol", event.target.value),
+                  children: [
+                    jsx("option", { value: "auto", children: t("protocolAuto") }, "auto"),
+                    jsx("option", { value: "json", children: t("protocolJson") }, "json"),
+                    jsx("option", { value: "qwen3guard", children: t("protocolQwen3Guard") }, "qwen3guard"),
+                  ],
+                }),
+              ],
+            }),
+            jsx("p", {
+              className: "dshAutoCheckHint",
+              children: t("hint"),
+            }),
+            jsx("p", {
+              className: "dshAutoCheckHint",
+              children: t("protocolHint"),
+            }),
+            protocol === "qwen3guard"
+              ? jsx("p", {
+                  className: "dshAutoCheckNotice",
+                  children: t("protocolWarning"),
+                })
+              : null,
+            state.catalogStatus === "loading"
+              ? jsx("p", {
+                  className: "dshAutoCheckNotice",
+                  role: "status",
+                  children: t("loading"),
+                })
+              : null,
+            state.catalogStatus === "error"
+              ? jsxs("p", {
+                  className: "dshAutoCheckError",
+                  role: "alert",
+                  children: [
+                    jsx("span", { children: t("loadFailed") }),
+                    jsx("button", {
+                      type: "button",
+                      disabled: state.saving,
+                      onClick: () => props.retryCatalog(),
+                      children: t("retry"),
+                    }),
+                  ],
+                })
+              : null,
+            state.catalogPartial
+              ? jsx("p", {
+                  className: "dshAutoCheckNotice",
+                  children: t("partial"),
+                })
+              : null,
+            state.catalogStatus === "ready" && state.groups.length === 0
+              ? jsx("p", {
+                  className: "dshAutoCheckNotice",
+                  children: t("empty"),
+                })
+              : null,
+          ],
+        }),
+      });
+    }
+
+    const inject = ["slots", "locale", "remote", "remote.session", "configForms"];
+
+    function apply(ctx) {
+      const t = ctx.locale.bind(NS);
+      ctx.effect(() => ctx.locale.register(NS, { zh, en }), "dsh-auto-check: dictionaries");
+
+      const card = new AutoCheckCardController(
+        ctx,
+        ctx.configForms.get(ENTRY_ID),
+      );
+      ctx.effect(() => () => card.dispose(), "dsh-auto-check: form subscription");
+
+      ctx.effect(
+        () =>
+          ctx.configForms.whileServed([ENTRY_ID], () =>
+            ctx.slots.inject("plugins.item", () =>
+              ctx.slots.register(
+                {
+                  name: "plugins.item",
+                  id: ENTRY_ID,
+                  order: 34,
+                  label: () => t("title"),
+                  locale: NS,
+                  inject: () => ({
+                    ...card.inject(),
+                    retryCatalog: () => card.refreshCatalog(),
+                    selectRoute: (route) => card.selectRoute(route),
+                  }),
+                },
+                AutoCheckCard,
+              ),
+            ),
+          ),
+        "dsh-auto-check: page",
+      );
+    }
+
+    return { inject, apply };
+  },
+});

package/cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: dsh-auto-check
+      name: dsh-auto-check

package/icon.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 64 64">
+  <rect width="64" height="64" rx="14" fill="#1f6feb"/>
+  <path d="M20 44V20h7.5l4.5 13 4.5-13H44v24h-6V30l-4 12h-4l-4-12v14z" fill="#fff"/>
+  <path d="M46 38l3 6 6 3-6 3-3 6-3-6-6-3 6-3z" fill="#ffd166"/>
+</svg>

package/lib/index.js

@@ -0,0 +1,46 @@
+import { Service } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+import { routeReview } from "./review-route.js";
+
+/**
+ * Owns the reviewer route and rewrites Auto review requests before they reach
+ * the adapter. An empty provider or model keeps the shipped behaviour: the
+ * reviewer follows the main model selected for the session.
+ */
+class AutoCheckReviewer extends Service {
+  static Config = z.object({
+    provider: z.string().default("").volatile(),
+    model: z.string().default("").volatile(),
+    protocol: z.string().default("auto").volatile(),
+  });
+
+  constructor(ctx, config) {
+    super(ctx, "autoCheckReviewer");
+    this.config = config;
+
+    ctx.inject(["settings"], (child) => {
+      child.effect(() => child.settings.configure({ auto: false }, ctx.fiber));
+    });
+
+    ctx.inject(["llm"], (child) => {
+      child.effect(() =>
+        child.on(
+          "llm/stream",
+          (options, next) =>
+            routeReview(
+              options,
+              {
+                provider: this.config.provider.get(),
+                model: this.config.model.get(),
+                protocol: this.config.protocol.get(),
+              },
+              (request) => child.llm.stream(request),
+            ) ?? next(),
+          { global: true, prepend: true },
+        ),
+      );
+    });
+  }
+}
+
+export { AutoCheckReviewer as default };

package/lib/review-route.js

@@ -0,0 +1,250 @@
+/**
+ * Pure routing and protocol adaptation for Auto review requests.
+ *
+ * The shipped auto-review plugin renders its policy as the request's `system`
+ * prompt, and that prompt starts with this exact line. The request carries no
+ * session id or other metadata, so the prefix is the only stable marker.
+ */
+export const REVIEW_POLICY_PREFIX = "REVIEW_POLICY\n";
+
+/**
+ * Requests we have already rewritten. `llm/stream` listeners may re-enter
+ * `ctx.llm.stream`, and the re-entered request must pass through to the adapter
+ * instead of matching this plugin again. The set is module scoped because the
+ * profile loads this plugin once.
+ */
+const rewritten = new WeakSet();
+
+/**
+ * Whether one LLM request is the Auto review request.
+ * @param {{ system?: unknown }} options
+ * @returns {boolean}
+ */
+export function isReviewRequest(options) {
+  return (
+    typeof options.system === "string" &&
+    options.system.startsWith(REVIEW_POLICY_PREFIX)
+  );
+}
+
+/**
+ * Qwen3Guard model ids are usually `Qwen/Qwen3Guard-Gen-4B` or
+ * `Qwen3Guard-Gen-8B`; the family name is enough to select the adapter.
+ * @param {unknown} model
+ * @returns {boolean}
+ */
+export function isQwen3GuardModel(model) {
+  return typeof model === "string" && /qwen3guard/i.test(model);
+}
+
+/**
+ * Resolve the output protocol for a target route.
+ *
+ * `auto` uses the Qwen3Guard adapter only when the target model is in that
+ * family, so selecting a Qwen3Guard model works without a second setting.
+ * `json` keeps the shipped auto-review protocol. `qwen3guard` forces the
+ * adapter even for a differently named model (for example a local alias).
+ *
+ * @param {{ protocol?: unknown }} route
+ * @param {unknown} targetModel
+ * @returns {"json" | "qwen3guard"}
+ */
+export function resolveReviewProtocol(route, targetModel) {
+  const protocol = String(route.protocol ?? "auto").trim().toLowerCase();
+  if (protocol === "qwen3guard") return "qwen3guard";
+  if (protocol === "json") return "json";
+  return isQwen3GuardModel(targetModel) ? "qwen3guard" : "json";
+}
+
+/**
+ * Collect the text Auto review sent for the pending tool call.
+ * @param {{ messages?: unknown }} options
+ * @returns {string}
+ */
+export function reviewText(options) {
+  const messages = Array.isArray(options.messages) ? options.messages : [];
+  const parts = [];
+  for (const message of messages) {
+    if (typeof message?.content === "string") {
+      parts.push(message.content);
+      continue;
+    }
+    if (!Array.isArray(message?.content)) continue;
+    for (const block of message.content) {
+      if (block?.type === "text" && typeof block.text === "string") {
+        parts.push(block.text);
+      }
+    }
+  }
+  if (parts.length > 0) return parts.join("\n\n");
+  return typeof options.messages === "string" ? options.messages : "";
+}
+
+/**
+ * Build the request Qwen3Guard expects.
+ *
+ * Qwen3Guard-Gen uses a fixed chat template for safety classification and does
+ * not follow auto-review's JSON policy. Sending the policy as a system message
+ * would be classified as part of the content, so only the pending-action text
+ * is forwarded as the user turn. The output is short (`Safety:` plus
+ * `Categories:`), so 128 tokens is ample.
+ *
+ * @param {object} options - immutable Auto review request.
+ * @param {string} provider
+ * @param {string} model
+ * @returns {object}
+ */
+export function qwen3GuardRequest(options, provider, model) {
+  const { system: _system, messages: _messages, ...rest } = options;
+  return {
+    ...rest,
+    provider,
+    model,
+    messages: [
+      {
+        role: "user",
+        content: [{ type: "text", text: reviewText(options) }],
+      },
+    ],
+    maxTokens: 128,
+  };
+}
+
+/**
+ * Map a Qwen3Guard safety label to auto-review's risk/decision protocol.
+ *
+ * `Safe` allows. `Unsafe` is high risk and denies. `Controversial` is context
+ * dependent; this adapter treats it as medium risk and denies so the user can
+ * still decide through auto-review's ask path when the downstream policy
+ * allows. A missing label fails closed.
+ *
+ * @param {string} text
+ * @returns {{ risk: "low" | "medium" | "high", decision: "allow" | "deny", reason?: string }}
+ */
+export function qwen3GuardDecision(text) {
+  const label = /Safety:\s*(Safe|Unsafe|Controversial)/i.exec(text)?.[1]?.toLowerCase();
+  const categories = /Categories:\s*([^\n]+)/i.exec(text)?.[1]?.trim();
+  const detail =
+    categories !== undefined && !/^none$/i.test(categories)
+      ? `categories: ${categories}`
+      : "no category";
+
+  if (label === "safe") return { risk: "low", decision: "allow" };
+  if (label === "controversial") {
+    return {
+      risk: "medium",
+      decision: "deny",
+      reason: `Qwen3Guard: Controversial (${detail})`,
+    };
+  }
+  if (label === "unsafe") {
+    return {
+      risk: "high",
+      decision: "deny",
+      reason: `Qwen3Guard: Unsafe (${detail})`,
+    };
+  }
+
+  const snippet = text.trim().replace(/\s+/g, " ").slice(0, 200);
+  return {
+    risk: "high",
+    decision: "deny",
+    reason: snippet === ""
+      ? "Qwen3Guard returned no Safety label"
+      : `Qwen3Guard returned no Safety label: ${snippet}`,
+  };
+}
+
+/**
+ * Consume Qwen3Guard's native text stream and emit the one-text-block JSON
+ * stream auto-review's `readDecision` requires.
+ *
+ * Adapter errors are passed through as their terminal finish chunk so
+ * auto-review keeps its existing fail-closed error path. A successful stream
+ * becomes `{risk, decision, reason?}`, preceded by no reasoning blocks.
+ *
+ * @param {AsyncIterable<object>} stream
+ * @returns {AsyncGenerator<object>}
+ */
+export async function* adaptQwen3GuardStream(stream) {
+  let text = "";
+  let usage;
+  let finish;
+
+  for await (const chunk of stream) {
+    if (chunk === null || typeof chunk !== "object") continue;
+    switch (chunk.type) {
+      case "text-delta":
+        text += typeof chunk.text === "string" ? chunk.text : "";
+        break;
+      case "usage":
+        usage = chunk;
+        break;
+      case "finish":
+        finish = chunk;
+        break;
+      default:
+        break;
+    }
+  }
+
+  if (
+    finish !== undefined &&
+    (finish.reason?.kind === "error" || finish.reason?.kind === "aborted")
+  ) {
+    yield finish;
+    return;
+  }
+
+  const body = JSON.stringify(qwen3GuardDecision(text));
+  yield { type: "block-start", index: 0, blockType: "text" };
+  yield { type: "text-delta", index: 0, text: body };
+  yield { type: "block-end", index: 0, block: { type: "text", text: body } };
+  if (usage !== undefined) yield usage;
+  yield { type: "finish", reason: { kind: "stop" } };
+}
+
+/**
+ * Rewrite an Auto review request to the configured reviewer route.
+ *
+ * Returns `undefined` when the request should continue down the normal
+ * waterfall: it is not a review, the target route is incomplete, it already
+ * names the configured route under the plain JSON protocol, or it is the
+ * re-entered copy created by this function.
+ *
+ * @param {object} options - immutable LLM request.
+ * @param {{ provider?: unknown, model?: unknown, protocol?: unknown }} route - configured route.
+ * @param {(request: object) => unknown} dispatch - sends a request to the LLM service.
+ * @returns the dispatched stream for a rewritten request, otherwise `undefined`.
+ */
+export function routeReview(options, route, dispatch) {
+  if (rewritten.has(options)) {
+    rewritten.delete(options);
+    return undefined;
+  }
+
+  if (!isReviewRequest(options)) return undefined;
+
+  const provider = String(route.provider ?? "").trim();
+  const model = String(route.model ?? "").trim();
+  if ((provider === "") !== (model === "")) return undefined;
+  const targetProvider = provider === "" ? options.provider : provider;
+  const targetModel = model === "" ? options.model : model;
+  if (typeof targetProvider !== "string" || typeof targetModel !== "string") {
+    return undefined;
+  }
+  if (targetProvider === "" || targetModel === "") return undefined;
+
+  const protocol = resolveReviewProtocol(route, targetModel);
+  const sameRoute =
+    options.provider === targetProvider && options.model === targetModel;
+  if (protocol === "json" && sameRoute) return undefined;
+
+  const next =
+    protocol === "qwen3guard"
+      ? qwen3GuardRequest(options, targetProvider, targetModel)
+      : { ...options, provider: targetProvider, model: targetModel };
+  rewritten.add(next);
+  const stream = dispatch(next);
+  return protocol === "qwen3guard" ? adaptQwen3GuardStream(stream) : stream;
+}

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Auto review model",
+    "description": "Choose a dedicated reviewer model for Auto review instead of following the main model."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "自动审查模型",
+    "description": "为自动审查单独选择审查模型，不再跟随主模型。"
+  }
+}

package/package.json

@@ -1,6 +1,52 @@
 {
   "name": "dsh-auto-check",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Give DeepSeek Harness Auto review its own reviewer model instead of following the main model.",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./client.js",
+    "./package.json": "./package.json",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg"
+  },
+  "files": [
+    "lib/*.js",
+    "client.js",
+    "locale/*.json",
+    "icon.svg",
+    "cordis.patch.yml",
+    "README.md",
+    "LICENSE"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ltzXiaoYanMo/dsh-auto-check.git"
+  },
+  "homepage": "https://github.com/ltzXiaoYanMo/dsh-auto-check#readme",
+  "bugs": {
+    "url": "https://github.com/ltzXiaoYanMo/dsh-auto-check/issues"
+  },
+  "scripts": {
+    "test": "node --test test/review-route.test.mjs"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-settings",
+        "@deepseek-ai/dsh-client-ui-plugin-manager",
+        "@deepseek-ai/dsh-api-remotes"
+      ]
+    }
+  },
+  "dependencies": {
+    "dsh-auto-check": "^0.1.0"
+  }
+}