dsh-openwrite 0.2.28 → 0.2.33

package/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [yyyy] [name of copyright owner]
+   Copyright 2026 The OpenWrite Project Authors
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

package/README.md

@@ -10,7 +10,7 @@
 <p align="center">在 DeepSeek Harness 中规划、写作、审稿和管理长篇小说。</p>
 
 <p align="center">
-  <a href="package.json"><img src="https://img.shields.io/badge/dsh-0.2.1--rc.3-2563eb" alt="dsh 0.2.1-rc.3"></a>
+  <a href="package.json"><img src="https://img.shields.io/badge/dsh-0.2.1--rc.5-2563eb" alt="dsh 0.2.1-rc.5"></a>
   <a href="package.json"><img src="https://img.shields.io/badge/Node-%E2%89%A522.19-15803d" alt="Node >= 22.19"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-Apache--2.0-0f766e" alt="Apache-2.0"></a>
   <a href="https://dsh-plugin.org/plugins/lipu-jpg/openwrite"><img src="https://dsh-plugin.org/badges/listed.svg" alt="Listed on dsh-plugin.org"></a>
@@ -27,9 +27,48 @@
 这是 [OpenWrite](https://github.com/LiPu-jpg/Openwrite/tree/native-core) 的 dsh 插件版本。
 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) 提供 Agent 与交互界面，OpenWrite Core 提供小说领域能力；人物、设定、大纲、正文和评审保存在本地作品目录。
 
-## 开发中：0.2.28（未发布）
+## 开发中：0.2.29（未发布）
 
-Core 5.8.20 候选继续修复正文最后输入漏存、审稿修订越过选区，以及真实 Markdown 编辑器格式转换导致的选区拒绝，见 [正文编辑与审稿补修](docs/EDITOR_SAFETY_REPAIRS.md)。前轮修复见 [选区与升级补修](docs/SELECTION_UPGRADE_REPAIRS.md)。宿主正式发布与 Android/Termux 真机两项继续跟踪，本轮不发布；下面的 npm/GitHub 安装入口仍为已发布的 0.2.27。
+增加 `pythonPath` / `OPENWRITE_PYTHON` 和显式依赖目录配置，允许使用已准备依赖的 Python，
+跳过 uv 与解释器下载；补充 Android/Termux 的本机 external Studio 步骤，以及旧版安装选择诊断。
+配置和边界见 [安装说明](docs/INSTALL.md#bring-your-own-python)。同时补齐手机后台输入保留、独立 Studio 正文草稿恢复、触屏选区与下载，并加入 Chromium / WebKit 发布回归，见 [手机验收说明](docs/MOBILE_READINESS.md)。正式可安装版本仍为下方的 0.2.28；
+同时修复审稿证据漏填误判与机器批注污染，候选捆绑 Core 5.8.22，见 [#146 修复说明](docs/ISSUE_146_REVIEW_EVIDENCE.md)。
+Android 完整工具验收与宿主升级保护发布继续在 [#123](https://github.com/LiPu-jpg/Openwrite/issues/123) 跟踪。
+
+## 0.2.33
+
+- **深度研究搜索默认走宿主 DSH**：托管运行时把 `ctx.web` 的搜索/抓取经环回中继交给 Core，默认 provider `dsh`，
+  不需要第三方搜索 Key；外部 Studio 仍默认 `bocha`。
+- **研究页新增搜索设置**：提供方、API Key、记住 Key；`dsh` 显示无需 Key。保存与 `novel_research_settings_save`
+  同路由，设置按作品作用域落盘。
+- 新增宿主 `host-web.ts` 中继（`/search`、`/fetch`、Bocha 兼容 `/bocha`，仅 127.0.0.1 + 机器 token）和 Core
+  handshake；DeepResearch 仍可选，首次使用需在 integration 目录 `pnpm install --frozen-lockfile`。
+- 搜索默认值放到左下角 **OpenWrite → 设置 → 搜索**（机器级默认，新作品生效；单个作品可在研究页覆盖）。
+- 研究 `quality` 在启动子进程前校验为 `advisory` / `balanced` / `strict`。
+- 修复非 ASCII `Authorization` 头返回 500 的问题，认证比较改为 UTF-8 bytes。
+- 左下角设置页视觉重做：搜索 provider 卡片、胶囊 Tab、卡片化配置块与主渐变保存按钮，对齐 dsh-our-free-model。
+
+## 0.2.30
+
+- **联动插件可执行接入**：`dsh-our-free-model` 接入按钮现在写 profile 并把写作/评审路由切到该模型（其余路由保留、二次确认、部分失败如实报告）；`dsh-ops` 的挂载计划（文件工具/渐进发现/无 shell/不替换官方工具）显示在「联动插件」区；`dsh-dog` 新增非斜杠技能 `dog-delivery-verification`，把正文与评审证据写成 handoff 图交给 `dog_validate`/`dog_create`/`dog_run` 独立验收。详见 [联动插件说明](docs/COMPANION_PLUGINS.md)。
+
+本轮候选还包含两项发布阻塞修复，见 [#149/#150/#151 修复说明](docs/ISSUES_149_150_151.md)：
+
+- 兼容精确宿主 dsh `0.2.1-rc.4` 与 `0.2.1-rc.5`，修复 `plugin does not support the DSH version in use` 直接拒装（[#150](https://github.com/LiPu-jpg/Openwrite/issues/150)/[#151](https://github.com/LiPu-jpg/Openwrite/issues/151)/[#142](https://github.com/LiPu-jpg/Openwrite/issues/142)）。
+- 新建会话选择器不再为每个已发布版本注册预设别名，只保留会话真实引用过的旧版本（[#149](https://github.com/LiPu-jpg/Openwrite/issues/149)）；工作台入口改用稳定预设 id。
+
+本轮候选还加入**可选联动插件**支持，见 [联动插件说明](docs/COMPANION_PLUGINS.md)：检测到 [dsh-ops](https://github.com/T-Auto/dsh-ops)
+时，用其官方预设接口挂载有界文件工具与渐进发现；检测到 [dsh-our-free-model](https://github.com/Ebony-Vinyl/dsh-our-free-model) 时，
+在工作台「联动插件」区显示状态与接入提示。两者均为可选项，未安装时行为与之前一致；任何判定失败都回退到 OpenWrite 自己的实现。
+同时**移除了内置的 DoG 引擎**（原 `vendor/dsh-dog`）：包里不再有 `dog_*` 工具与「DoG 验收」入口，
+三个查询技能改为直接读 OpenWrite 自己的评审/交付/导入产物；需要 DoG 图形验证可自行安装
+[@dsh-external/dsh-dog](https://github.com/Fun10165/dsh-dog)。
+
+## 0.2.28
+
+0.2.28 捆绑 Core 5.8.20，最终 22 项 CI 全部通过；修复正文最后输入漏存、审稿修订越过选区，以及真实 Markdown 编辑器格式转换导致的选区拒绝，见 [正文编辑与审稿补修](docs/EDITOR_SAFETY_REPAIRS.md)。并包含前轮 [选区与升级补修](docs/SELECTION_UPGRADE_REPAIRS.md)、[写作与审稿改进](docs/ISSUES_121_123.md)。
+
+[GitHub 0.2.28](https://github.com/LiPu-jpg/Openwrite/releases/tag/v0.2.28) 与 [npm 0.2.28](https://www.npmjs.com/package/dsh-openwrite/v/0.2.28) 均已发布，npm `latest` 已更新为 0.2.28；两处公开下载包均与 CI 原始安装包逐字节一致。#123 的宿主正式发布和 Android/Termux 真机两项仍未完成，作为已知限制继续跟踪。
 
 ## 0.2.27
 
@@ -46,12 +85,12 @@ Android/ARM 外部 Studio 诊断，以及连载写作可靠性、完整上下文
 
 ## 快速安装
 
-**0.2.27 标准插件包**兼容精确 dsh 版本 **0.1.2-rc.1 / 0.1.5-alpha.1 / 0.2.0-rc.2 / 0.2.1-rc.2 / 0.2.1-rc.3**。五个版本均已完成 Web 工作台渲染与 DoG 数据读取验证，Windows Electron 桌面端启动/恢复链路尚未实机复测。可下载版本、各平台验收结果和 SHA-256 以 [GitHub Release](https://github.com/LiPu-jpg/Openwrite/releases/latest) 附件为准；验收方法见 [发布验收](docs/RELEASE_ACCEPTANCE.md)。商城所需的精确预览版兼容性、验证范围和安装限制见 [DSH STORE 接入](docs/DSH_STORE.md)。
+**0.2.28 标准插件包**兼容精确 dsh 版本 **0.1.2-rc.1 / 0.1.5-alpha.1 / 0.2.0-rc.2 / 0.2.1-rc.2 / 0.2.1-rc.3**。五个版本均已完成 Web 工作台渲染与 DoG 数据读取验证；三系统原生安装和 Electron 回归通过，报告者也补齐了 Windows 历史会话恢复实测。可下载版本、各平台验收结果和 SHA-256 以 [GitHub Release](https://github.com/LiPu-jpg/Openwrite/releases/latest) 附件为准；验收方法见 [发布验收](docs/RELEASE_ACCEPTANCE.md)。商城所需的精确预览版兼容性、验证范围和安装限制见 [DSH STORE 接入](docs/DSH_STORE.md)。
 
-正式发行状态以 [npm 版本列表](https://www.npmjs.com/package/dsh-openwrite?activeTab=versions) 和 [GitHub Release](https://github.com/LiPu-jpg/Openwrite/releases/latest) 为准。以下是 0.2.27 精确版本的安装命令；发布时两处使用同一份验收产物：
+正式发行状态以 [npm 版本列表](https://www.npmjs.com/package/dsh-openwrite?activeTab=versions) 和 [GitHub Release](https://github.com/LiPu-jpg/Openwrite/releases/latest) 为准。以下是 0.2.28 精确版本的安装命令；发布时两处使用同一份验收产物：
 
 ```sh
-dsh plugin --profile web add -w https://github.com/LiPu-jpg/Openwrite/releases/download/v0.2.27/dsh-openwrite-0.2.27.tgz
+dsh plugin --profile web add -w https://github.com/LiPu-jpg/Openwrite/releases/download/v0.2.28/dsh-openwrite-0.2.28.tgz
 dsh web
 ```
 
@@ -81,6 +120,8 @@ dsh web
 
 ### dsh 0.2 桌面端升级
 
+`0.2.28`（Core 5.8.20）已发布。升级前完全退出 Desktop（含托盘）及 dsh，备份 profile；宿主原生升级保护尚未正式发布，停机升级工具及限制见 [升级说明](docs/ISSUES_98_100.md#离线升级和损坏修复)。完成后重启宿主并刷新界面。
+
 `0.2.27`（Core 5.8.16）包含 Go 工作台认证、评审输出预算及后台重试补漏，并保留 #105–#113 与 #103/#104 的既有修复；原始场景仍待验证的条目见 [#123](https://github.com/LiPu-jpg/Openwrite/issues/123)。升级前完全退出 dsh/桌面客户端；安装后重新启动并刷新浏览器。原有作品、凭据和会话继续保留，历史版本预设用于恢复旧会话。受限平台使用外部 Studio，OpenCode Go 的服务商使用范围和配置要求见上述文档。
 
 `0.2.25`（Core 5.8.12）已在 [GitHub Release](https://github.com/LiPu-jpg/Openwrite/releases/tag/v0.2.25) 与 [npm](https://www.npmjs.com/package/dsh-openwrite/v/0.2.25) 发布，新增连载体检、分段续写、共享术语/范本、章组审计和漂移裁决，并修复验收与任务可观测性。范围、离线升级工具及宿主侧限制见 [#98–#100 实现说明](docs/ISSUES_98_100.md)，完整验收见 [发布验收](docs/RELEASE_ACCEPTANCE.md#025)。
@@ -183,7 +224,7 @@ dsh web
 packages/openwrite-bridge/   小说工具与后端桥接
 packages/studio-panel/       dsh 原生工作台
 presets/openwrite/          OpenWrite 创作预设与技能
-scripts/                   安装、启动、检查与 DoG 适配
+scripts/                   安装、启动与检查
 conductor/                 连续写章、评审与修订编排
 ```
 
@@ -193,7 +234,7 @@ conductor/                 连续写章、评审与修订编排
 ## 许可与来源
 
 项目采用 [Apache-2.0](LICENSE)。`oh-story-*` 技能和随包编辑器保留各自目录中的原有许可证。
-Logo 基于 OpenWrite `native-core` 分支，已调整深浅主题配色；基于 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness)，图谱集成使用 [dsh-dog](https://github.com/Fun10165/dsh-dog)。
+Logo 基于 OpenWrite `native-core` 分支，已调整深浅主题配色；基于 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness)，图谱验证可选装第三方 [dsh-dog](https://github.com/Fun10165/dsh-dog)（内置引擎已移除）。
 
 生态目录：[dsh-TUI](https://github.com/ccch1mneyyy/dsh-TUI) · [社区插件市场](https://dshtui.com/plugins/)。OpenWrite 当前面向 DeepSeek Harness 的 `web` profile，使用 `dsh web` 打开创作工作台；尚未验证 dsh-TUI 界面兼容性。
 

package/THIRD_PARTY_NOTICES.md

@@ -1,8 +1,7 @@
 # Third-party components
 
 OpenWrite is Apache-2.0. The separately maintained Studio panel retains its MIT
-license. DoG is based on Fun10165/dsh-dog v1.2.0, BSD-3-Clause; its full license
-and integration changes are in vendor/dsh-dog/LICENSE and UPSTREAM.md.
+license.
 
 The editor ships Vditor and its auxiliary files with the upstream license in
 packages/studio-panel/vendor/vditor/LICENSE. OpenWrite preset skills retain
@@ -21,7 +20,9 @@ they are not inlined into the plugin's browser code.
 The release includes an OpenWrite-built cryptography 50.0.1 wheel for macOS
 x86_64 because upstream discontinued Intel Mac wheels. It is built from the
 SHA-256 pinned upstream source with statically linked OpenSSL 3.6.3. The wheel
-retains upstream licenses; OpenSSL's full license is in release/wheels/licenses.
+retains upstream licenses; OpenSSL's full license is in
+release/wheels/licenses/OPENSSL-3.6.3-LICENSE.txt (Apache License 2.0,
+reproduced verbatim from the wheel with its SHA-256 recorded in that file).
 Source hash, toolchain, linkage inspection and the native CI build URL are in
 release/wheels/provenance.json. No cryptography source code was modified.
 

package/companions.mjs

@@ -0,0 +1,508 @@
+// Companion-plugin detection. OpenWrite ships its own DoG engine and works
+// without any companion; when a companion plugin is installed in the same
+// profile AND its declared host range covers the running host, the companion's
+// newest implementation is used instead of ours. Every unknown answer is
+// fail-closed: detection problems keep our own implementation.
+import { readFile, readdir, stat, mkdir, writeFile, realpath } from 'node:fs/promises'
+import { createRequire } from 'node:module'
+import { pathToFileURL } from 'node:url'
+import { dirname, join, resolve } from 'node:path'
+
+/** Bundle names that identify each companion, with and without scope. */
+const companionNames = {
+  dog: ['@dsh-external/dsh-dog'],
+  ops: ['dsh-ops'],
+  freeModel: ['dsh-our-free-model', '@ebony-vinyl/dsh-our-free-model'],
+}
+
+/**
+ * The host constraint a companion actually declares.
+ *
+ * Most plugins declare `peerDependencies["@deepseek-ai/dsh"]`, and the host reads
+ * exactly that. Some (dsh-dog 1.4.x) declare only `@deepseek-ai/dsh-*`
+ * sub-packages instead; the host needs every one of them, so their ranges are the
+ * real constraint. Treating a missing `@deepseek-ai/dsh` peer as "no constraint"
+ * would report such a plugin usable on hosts where the host itself refuses it.
+ */
+function hostConstraint(manifest) {
+  const peers = manifest?.peerDependencies ?? {}
+  const direct = peers['@deepseek-ai/dsh']
+  if (typeof direct === 'string' && direct !== '') return { range: direct, source: '@deepseek-ai/dsh' }
+  const subpackage = Object.entries(peers)
+    .filter(([name]) => name.startsWith('@deepseek-ai/dsh-'))
+    .map(([, range]) => String(range))
+  if (subpackage.length > 0) return { range: subpackage.join(' '), source: '@deepseek-ai/dsh-*' }
+  return { range: null, source: null }
+}
+
+/**
+ * The public entry each companion must expose for OpenWrite to use it. A
+ * companion that is installed but does not expose its entry (an older release,
+ * or one that moved the API) is treated as absent: mounting a row whose import
+ * fails would take the whole preset composition down with it.
+ */
+const companionEntries = { ops: 'dsh-ops/integration' }
+
+/**
+ * The exact dsh-ops integration OpenWrite mounts. Detection builds it too, so an
+ * upstream release that stops accepting these options is reported instead of
+ * breaking the preset composition at load time.
+ */
+/** The exact options OpenWrite passes to the dsh-ops integration factory. */
+export const OPENWRITE_OPS_OPTIONS = Object.freeze({
+  preset: 'openwrite',
+  files: true,
+  discovery: true,
+  presentation: 'native',
+  replaceOfficial: false,
+  shell: false,
+})
+
+const opsIntegration = factory => factory({ ...OPENWRITE_OPS_OPTIONS })
+
+/** The small, serializable summary of a resolved dsh-ops plan. */
+export function summarizeOpsPlan(plan) {
+  return {
+    files: plan.files === true,
+    discovery: plan.discovery === true,
+    presentation: String(plan.presentation ?? ''),
+    shell: plan.shell === true,
+    replaceOfficial: plan.replaceOfficial === true,
+    residentTools: plan.residentTools === true,
+    residentNames: Array.isArray(plan.residentNames) ? plan.residentNames.length : 0,
+  }
+}
+
+const readJson = async path => JSON.parse(await readFile(path, 'utf8'))
+
+/** Compare two parsed versions, prerelease identifiers included. */
+function compareVersions(a, b) {
+  for (const key of ['major', 'minor', 'patch']) {
+    if (a[key] !== b[key]) return a[key] < b[key] ? -1 : 1
+  }
+  const [x, y] = [a.pre, b.pre]
+  if (x.length === 0 && y.length === 0) return 0
+  if (x.length === 0) return 1
+  if (y.length === 0) return -1
+  for (let index = 0; index < Math.max(x.length, y.length); index += 1) {
+    if (index >= x.length) return -1
+    if (index >= y.length) return 1
+    const left = x[index], right = y[index]
+    if (left === right) continue
+    const numeric = /^\d+$/.test(left) && /^\d+$/.test(right)
+    if (numeric) return Number(left) < Number(right) ? -1 : 1
+    return left < right ? -1 : 1
+  }
+  return 0
+}
+
+/** Parse `1.2.3-rc.4` into comparable parts; returns null when unparseable. */
+function parseVersion(value) {
+  const match = /^(\d+)(?:\.(\d+|[xX*]))?(?:\.(\d+|[xX*]))?(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec((value ?? '').trim())
+  if (!match) return null
+  const wildcard = part => part === undefined || /[xX*]/.test(part)
+  // `1.x.3` is not a version spelling npm accepts.
+  if (wildcard(match[2]) && match[3] !== undefined && !wildcard(match[3])) return null
+  if (wildcard(match[2]) && match[4] !== undefined) return null
+  return { major: +match[1], minor: +(wildcard(match[2]) ? 0 : match[2]), patch: +(wildcard(match[3]) ? 0 : match[3]),
+    pre: match[4] ? match[4].split('.') : [], partial: 3 - [match[2], match[3]].filter(wildcard).length }
+}
+
+/** One comparator: an optional operator plus its version spelling. */
+function parseComparator(comparator) {
+  const match = /^(>=|<=|>|<|=|\^|~)?\s*(.+)$/.exec(comparator.trim())
+  if (!match) return null
+  const version = parseVersion(match[2].trim().replace(/^[vV]/, ''))
+  if (!version) return null
+  return { op: match[1] ?? '=', version }
+}
+
+/** The exclusive end of a spelled version prefix (`0.3` -> 0.4.0-0, `1` -> 2.0.0-0). */
+function upperBoundOf(spelling) {
+  const version = parseVersion(spelling.replace(/^[vV]/, ''))
+  if (!version) return null
+  if (version.partial === 3) return { ...version, pre: ['0'] }
+  return version.partial === 1
+    ? { major: version.major + 1, minor: 0, patch: 0, pre: ['0'] }
+    : { major: version.major, minor: version.minor + 1, patch: 0, pre: ['0'] }
+}
+
+/** Expand one comparator (`1.2.3`, `^1.2.3`, `~1.2.3`, `>=1.2.3`, `*`) into bounds. */
+function expandComparator(comparator) {
+  const trimmed = comparator.trim()
+  // `x`, `*`, `x.x.x` and most operators applied to them accept any version;
+  // the strict `>x` / `<x` accept none.
+  const wildcard = /^((?:>=|<=|>|<|=|\^|~)?)\s*[xX*](?:\.[xX*]){0,2}$/.exec(trimmed)
+  if (trimmed === '' || wildcard) {
+    const strict = wildcard !== null && (wildcard[1] === '>' || wildcard[1] === '<')
+    return strict ? [] : [{ op: '>=', version: { major: 0, minor: 0, patch: 0, pre: [] } }]
+  }
+  const parsed = parseComparator(trimmed)
+  if (!parsed) return null
+  const { op, version } = parsed
+  const upper = (major, minor, patch) => ({ op: '<', version: { major, minor, patch, pre: ['0'] } })
+  if (op !== '^' && op !== '~') {
+    // npm X-range semantics for a partial spelling, taken from semver's own Range
+    // expansion (verified comparator by comparator):
+    //   `0.2`   -> >=0.2.0 <0.3.0-0      `<=0.2` -> <0.3.0-0
+    //   `<0.3`  -> <0.3.0-0              `<=0.3` -> <0.4.0-0
+    //   `>0.2`  -> >=0.3.0               `>=0.3` -> >=0.3.0
+    //   `>0.3`  -> >=0.4.0               `<1`    -> <1.0.0-0
+    //   `<=0`   -> <1.0.0-0              `>0`    -> >=1.0.0
+    // `<` bounds at the spelled prefix; `<=`, `>` and `>=` bound one component
+    // further. Zero-filling the bound instead would make `>0.2` accept 0.2.5
+    // (fail open) and `<=0.2` reject it (fail closed).
+    if (version.partial < 3) {
+      const start = { major: version.major, minor: version.minor, patch: version.patch, pre: [] }
+      const end = version.partial === 1
+        ? { major: version.major + 1, minor: 0, patch: 0, pre: ['0'] }
+        : { major: version.major, minor: version.minor + 1, patch: 0, pre: ['0'] }
+      const here = { major: version.major, minor: version.minor, patch: 0, pre: ['0'] }
+      if (op === '=') return [{ op: '>=', version: start }, { op: '<', version: end }]
+      if (op === '>') return [{ op: '>=', version: { ...end, pre: [] } }]
+      if (op === '<') return [{ op: '<', version: here }]
+      if (op === '<=') return [{ op: '<', version: end }]
+      // `>=0.3` starts AT the spelled prefix; `>0.3` starts one component later.
+      return [{ op: '>=', version: op === '>=' ? start : end }]
+    }
+    return [{ op, version }]
+  }
+  const floor = { op: '>=', version }
+  // npm X-ranges inside a caret/tilde: `^0` and `~0` both stop at 1.0.0.
+  if (version.partial === 1) return [floor, upper(version.major + 1, 0, 0)]
+  if (op === '~') return [floor, upper(version.major, version.minor + 1, 0)]
+  if (op === '^' && version.partial === 2 && version.major === 0) return [floor, upper(0, version.minor + 1, 0)]
+  if (version.major > 0) return [floor, upper(version.major + 1, 0, 0)]
+  if (version.minor > 0) return [floor, upper(0, version.minor + 1, 0)]
+  return [floor, upper(0, 0, version.patch + 1)]
+}
+
+/** Split one `||` alternative into comparators, keeping `>= 1.2.3` together. */
+function expandAlternative(alternative) {
+  const trimmed = alternative.trim()
+  if (trimmed === '') return [{ op: '>=', version: { major: 0, minor: 0, patch: 0, pre: [] } }]
+  const comparators = []
+  const verbatim = []
+  let cursor = 0
+  for (const match of trimmed.matchAll(/(>=|<=|>|<|=|\^|~)?\s*(v?[0-9xX*][^\s]*)/g)) {
+    verbatim.push({ op: match[1] ?? '=', version: match[2].replace(/^[vV]/, '') })
+    // Anything but whitespace between two comparators is a spelling we refuse,
+    // except the lone `-` of a hyphen range (`1.2.3 - 2.3.4`).
+    const gap = trimmed.slice(cursor, match.index)
+    if (gap.trim() !== '' && gap.trim() !== '-') return null
+    const expanded = expandComparator(`${match[1] ?? ''} ${match[2]}`)
+    if (expanded === null) return null
+    comparators.push(...expanded)
+    cursor = match.index + match[0].length
+  }
+  // (hyphen operands are re-emitted verbatim below)
+  if (trimmed.slice(cursor).trim() !== '') return null
+  // A hyphen range (`1.2.3 - 2.3.4`, `0.2 - 0.3`) is two partial-or-full
+  // versions with a lone `-` between them; npm expands it to `>=lo <=hi` with
+  // both bounds verbatim, so the X-range rule must not rewrite them. The
+  // tokenizer drops the `-`, so detect it from the original text.
+  if (verbatim.length === 2 && verbatim.every(item => item.op === '=')
+    && /(^|\s)-(\s|$)/.test(trimmed)) {
+    // npm's hyphen range is the X-range of the lower bound plus the prefix end of
+    // the upper one: `0.2 - 0.3` is `>=0.2.0 <0.4.0-0`, `1 - 2` is
+    // `>=1.0.0 <3.0.0-0`. Both operands keep their own partial expansion.
+    const lower = parseVersion(verbatim[0].version.replace(/^[vV]/, ''))
+    const upper = parseVersion(verbatim[1].version.replace(/^[vV]/, ''))
+    // The lower operand is always inclusive; the upper one keeps its own value
+    // when it is a full version and bumps to its prefix end when it is partial.
+    return [{ op: '>=', version: lower }, upper.partial === 3
+      ? { op: '<=', version: upper }
+      : { op: '<', version: upperBoundOf(verbatim[1].version) }]
+  }
+  return comparators
+}
+
+/**
+ * Whether one version satisfies one range. Implements the subset the dsh host
+ * uses: `||` alternatives, `=`/`>`/`>=`/`<`/`<=`/`^`/`~`, X-ranges.
+ *
+ * The host decides with `semver.satisfies(version, range, { includePrerelease: true })`
+ * (dsh-app-boot `unmetRequirements` → `satisfies`). That flag relaxes npm's rule
+ * that a prerelease only matches a comparator carrying the same
+ * major/minor/patch, so `0.2.1-rc.5` DOES satisfy `>=0.2.0-rc.2 <0.2.2-0`.
+ *
+ * Implementing the stricter rule here made this detection more conservative than
+ * the host: dsh-ops and dsh-our-free-model were reported "installed but the host
+ * does not allow it" on 0.2.1-rc.* while the host loaded both. Detection must
+ * match the host, not npm's install-time resolution.
+ */
+export function satisfiesRange(version, range) {
+  const parsed = parseVersion(version)
+  // Only a complete version is testable; partial spellings belong to ranges.
+  if (!parsed || parsed.partial !== 3 || typeof range !== 'string') return false
+  for (const alternative of range.split('||')) {
+    const comparators = expandAlternative(alternative)
+    if (comparators === null || comparators.length === 0) continue
+    if (comparators.every(({ op, version: bound }) => {
+      const order = compareVersions(parsed, bound)
+      return op === '=' ? order === 0
+        : op === '>' ? order > 0
+          : op === '>=' ? order >= 0
+            : op === '<' ? order < 0
+              : order <= 0
+    })) return true
+  }
+  return false
+}
+
+/** Walk up from one path to the version of the host package that owns it. */
+async function hostVersionAbove(path) {
+  // Resolve symlinks first. The running host is usually started through the
+  // `dsh` shim in the npm global bin directory, which is a symlink into
+  // lib/node_modules/@deepseek-ai/dsh/lib/bin.js. `path.resolve` does not follow
+  // symlinks, so walking up from the shim never reaches the package and the
+  // version silently falls through to whatever this checkout happens to depend
+  // on - reported a source checkout's 0.1.2-rc.1 devDependency while the real
+  // host was 0.2.1-rc.5.
+  let directory = dirname(await realpath(path).catch(() => resolve(path)))
+  while (true) {
+    const manifest = await readJson(join(directory, 'package.json')).catch(() => null)
+    if (manifest?.name === '@deepseek-ai/dsh' && typeof manifest.version === 'string') return manifest.version
+    const parent = dirname(directory)
+    if (parent === directory) return null
+    directory = parent
+  }
+}
+
+/**
+ * The running host version. A host installed into a profile is read from that
+ * profile; otherwise the host sub-packages this plugin already resolves are
+ * read, because the harness publishes them in lockstep with `@deepseek-ai/dsh`.
+ * `OPENWRITE_HOST_VERSION` overrides every source for diagnostics and tests.
+ * Unknown when nothing resolves, which keeps every companion decision
+ * fail-closed.
+ */
+export async function resolveHostVersion(home) {
+  const override = process.env.OPENWRITE_HOST_VERSION
+  if (typeof override === 'string' && parseVersion(override)) return override
+  for (const profile of await readdir(join(home, 'profiles')).catch(() => [])) {
+    const installed = join(home, 'profiles', profile, 'node_modules', '@deepseek-ai', 'dsh')
+    const version = await hostVersionAbove(join(installed, 'lib', 'index.js'))
+      ?? (await readJson(join(installed, 'package.json')).catch(() => null))?.version
+    if (typeof version === 'string' && parseVersion(version)) return version
+  }
+  // The entry this process was started from is the host that is actually
+  // running; it outranks whatever this checkout happens to depend on.
+  const entry = process.argv?.[1]
+  if (typeof entry === 'string') {
+    const version = await hostVersionAbove(entry)
+    if (version) return version
+  }
+  // Last resort: the host packages resolvable from here. In a source checkout
+  // that is this repo's own pinned devDependency, never the running host, so it
+  // can answer wrongly in both directions — prefer it over nothing only.
+  for (const name of ['@deepseek-ai/dsh', '@deepseek-ai/dsh-home-paths', '@deepseek-ai/dsh-settings', '@deepseek-ai/dsh-tools']) {
+    const version = await readJson(createRequire(import.meta.url).resolve(`${name}/package.json`)).then(manifest => manifest?.version).catch(() => null)
+    if (typeof version === 'string' && parseVersion(version)) return version
+  }
+  return null
+}
+
+/** Every profile bundle list plus a fingerprint of the manifests behind them. */
+async function readProfiles(home) {
+  const profiles = []
+  let fingerprint = ''
+  for (const name of await readdir(join(home, 'profiles')).catch(() => [])) {
+    const manifest = join(home, 'profiles', name, 'package.json')
+    let parsed, modified
+    try {
+      parsed = await readJson(manifest)
+      modified = (await stat(manifest)).mtimeMs
+    } catch { continue }
+    const bundles = parsed?.dsh?.profile?.bundles
+    if (!Array.isArray(bundles)) continue
+    profiles.push({ name, directory: join(home, 'profiles', name), bundles })
+    fingerprint += `${name}:${Math.round(modified)};`
+    // The companion's own manifest decides whether the running host is inside its
+    // declared range, so an upgrade that widens (or narrows) that range must
+    // invalidate the cache. Keying only on the profile manifest kept serving the
+    // previous verdict after a companion upgrade - the exact #150/#151/#142 class
+    // of bug, reachable again the moment the range changes.
+    for (const candidates of Object.values(companionNames)) {
+      for (const companion of candidates) {
+        const companionManifest = join(profiles[profiles.length - 1].directory, 'node_modules', ...companion.split('/'), 'package.json')
+        try {
+          fingerprint += `${companion}:${Math.round((await stat(companionManifest)).mtimeMs)};`
+        } catch { /* companion not installed in this profile */ }
+      }
+    }
+  }
+  return { profiles, fingerprint }
+}
+
+/** Locate one installed companion package inside a profile. */
+async function installedPackage(profile, names) {
+  for (const name of names) {
+    if (!profile.bundles.some(bundle => String(bundle).toLowerCase() === name.toLowerCase())) continue
+    const manifest = join(profile.directory, 'node_modules', ...name.split('/'), 'package.json')
+    const parsed = await readJson(manifest).catch(() => null)
+    if (parsed) {
+      const constraint = hostConstraint(parsed)
+      return { name, directory: join(profile.directory, 'node_modules', ...name.split('/')),
+        version: parsed.version, range: constraint.range, rangeSource: constraint.source }
+    }
+  }
+  return null
+}
+
+/**
+ * Load a companion's entry and build the integration OpenWrite would mount, so an
+ * entry that no longer accepts our options is caught here instead of taking the
+ * preset composition down with it. Returns null when usable, or why it is not.
+ */
+async function validateEntry(directory, entry, build) {
+  if (!resolvesEntry(directory, entry)) return `installed package does not expose ${entry}`
+  try {
+    const resolved = createRequire(join(directory, 'package.json')).resolve(entry)
+    const module = await import(pathToFileURL(resolved).href)
+    const factory = module.integration ?? module.default
+    if (typeof factory !== 'function') return `${entry} no longer exports an integration factory`
+    // The mounted row immediately calls `.apply` on the result, so a factory
+    // that returns nothing must be refused here rather than at activation.
+    const built = build(factory)
+    if (built === null || typeof built !== 'object' || typeof built.apply !== 'function') {
+      return `${entry} returned no plugin object`
+    }
+    return null
+  } catch (error) {
+    return `${entry} rejected the OpenWrite integration: ${error instanceof Error ? error.message : String(error)}`
+  }
+}
+
+/** Whether one package directory exposes the entry OpenWrite would import. */
+function resolvesEntry(directory, entry) {
+  try {
+    createRequire(join(directory, 'package.json')).resolve(entry)
+    return true
+  } catch { return false }
+}
+
+/**
+ * Whether a companion's own bundle patch is self-consistent.
+ *
+ * The host imports each `insert` row by its `name`, resolved as a package from
+ * the profile. A scoped package that ships a patch naming the bare package
+ * (`@ebony-vinyl/dsh-our-free-model` declaring `name: dsh-our-free-model`)
+ * therefore never activates: the host reports
+ * "Cannot find package 'dsh-our-free-model'". Detecting that here turns a
+ * panel that shows "available" and then fails to read the gateway into an
+ * accurate "installed but the host cannot load it".
+ */
+async function bundlePatchReason(directory, packageName) {
+  const manifest = await readJson(join(directory, 'package.json')).catch(() => null)
+  const patch = manifest?.dsh?.bundle?.patch
+  if (typeof patch !== 'string' || patch === '') return null
+  const text = await readFile(join(directory, patch), 'utf8').catch(() => null)
+  if (text === null) return `bundle patch ${patch} is missing`
+  // Minimal scan: every `name:` value in an insert block. A full YAML parse is
+  // deliberately avoided so a malformed patch cannot make detection itself fail.
+  const names = [...text.matchAll(/^\s*-?\s*name:\s*['"]?([^'"\n]+)['"]?\s*$/gm)].map(m => m[1].trim())
+  if (names.length === 0) return null
+  for (const name of names) {
+    if (name === packageName) continue
+    // A relative or subpath specifier is resolved against the package itself.
+    if (name.startsWith('.') || name.startsWith('#')) continue
+    try {
+      const resolved = createRequire(join(directory, 'package.json')).resolve(name)
+      if (resolved.startsWith(resolve(directory))) continue
+    } catch { /* fall through to the mismatch report */ }
+    return `bundle patch names ${name}, which is not this package (${packageName}); the host cannot load it`
+  }
+  return null
+}
+/**
+ * Why a companion is not usable because of its declared host constraint, or null
+ * when the constraint covers the running host.
+ *
+ * A companion may declare several constraints (dsh-dog declares one range per
+ * `@deepseek-ai/dsh-*` sub-package); the host needs all of them, so every one
+ * must cover. An unknown host version is reported rather than silently accepted,
+ * because "no constraint declared" and "cannot tell" must not read the same.
+ */
+function rangeExclusionReason(host, candidate) {
+  const range = candidate.range
+  if (range === null || range === undefined) {
+    return host === null || host === undefined
+      ? 'the running host version is unknown, so its declared range cannot be checked'
+      : null
+  }
+  if (host === null || host === undefined) {
+    const shown = candidate.rangeSource === '@deepseek-ai/dsh-*'
+      ? `${candidate.range.split(' ').filter(Boolean).length} @deepseek-ai/dsh-* peer ranges`
+      : `declared range ${range}`
+    return `the running host version is unknown, so ${shown} cannot be checked`
+  }
+  if (satisfiesRange(host, range)) return null
+  const source = candidate.rangeSource === '@deepseek-ai/dsh-*'
+    ? 'its @deepseek-ai/dsh-* peer ranges'
+    : `declared host range ${range}`
+  return `${source} excludes dsh ${host}`
+}
+
+/**
+ * Describe every companion: whether it is installed and whether the running host
+ * would load it.
+ */
+export async function detectCompanions(home, options = {}) {
+  const { profiles, fingerprint } = await readProfiles(home)
+  // An explicit host version wins; `undefined` means "resolve it" while an
+  // explicit null forces the unknown-host path.
+  const host = 'hostVersion' in options ? options.hostVersion : await resolveHostVersion(home)
+  const describe = async (names, entry, build) => {
+    // Every profile is examined: readdir order is unspecified, so stopping at
+    // the first match would make the answer depend on directory order when one
+    // profile carries a usable copy and another does not.
+    const found = []
+    for (const profile of profiles) {
+      const installed = await installedPackage(profile, names)
+      if (installed) found.push({ profile, ...installed })
+    }
+    if (found.length === 0) return { installed: false, usable: false, version: null, range: null, profile: null, reason: null }
+    const described = []
+    for (const candidate of found) {
+      const entryReason = entry === undefined ? null : await validateEntry(candidate.directory, entry, build)
+      // A companion whose own bundle patch cannot be loaded by the host is not
+      // usable however well its range matches: the panel would offer an
+      // integration that never activates.
+      const patchReason = entryReason ?? await bundlePatchReason(candidate.directory, candidate.name)
+      // A null range means the plugin declares no host constraint at all. That is
+      // not "usable everywhere": an unknown constraint is treated as covering,
+      // because the host would also accept it, but it is reported so the panel
+      // can say the range is unknown rather than asserting compatibility.
+      const rangeReason = patchReason ?? rangeExclusionReason(host, candidate)
+      const usable = rangeReason === null
+      described.push({ installed: true, usable, version: candidate.version ?? null, range: candidate.range ?? null,
+        rangeSource: candidate.rangeSource ?? null,
+        profile: candidate.profile.name, reason: rangeReason })
+    }
+    return described.find(candidate => candidate.usable) ?? described[0]
+  }
+  const [dog, ops, freeModel] = await Promise.all([
+    describe(companionNames.dog),
+    describe(companionNames.ops, companionEntries.ops, opsIntegration),
+    describe(companionNames.freeModel),
+  ])
+  const result = { host, dog, ops, freeModel }
+  const cache = join(home, 'openwrite', 'companions.json')
+  // The cache key must include this plugin's own version. Keying only on the
+  // profile manifests and the host meant an upgrade that changes the detection
+  // logic (new companion, corrected range semantics) kept serving the previous
+  // answer: a real 0.2.1-rc.5 host showed the old "ops excludes dsh 0.2.1-rc.5"
+  // verdict and no DoG row at all, until the manifests happened to change.
+  const build = await readJson(new URL('package.json', import.meta.url)).then(m => m?.version).catch(() => null)
+  const cached = await readJson(cache).catch(() => null)
+  if (cached?.fingerprint === fingerprint && cached.host === host && cached.build === build) {
+    // Serve the stored answer: recomputing on every call would re-read every
+    // profile and re-import the companion entry each time.
+    const { fingerprint: _fingerprint, build: _build, ...rest } = cached
+    return { ...rest, host, cached: true }
+  }
+  await mkdir(join(home, 'openwrite'), { recursive: true }).catch(() => {})
+  await writeFile(cache, JSON.stringify({ fingerprint, host, build, ...result }) + '\n').catch(() => {})
+  return { ...result, cached: false }
+}

package/cordis.patch.yml

@@ -7,5 +7,3 @@
         mode: managed
     - id: studio-panel
       name: ./packages/studio-panel/lib/index.js
-    - id: openwrite-dog
-      name: ./vendor/dsh-dog/lib/index.js