dsh-win-pwsh7 0.2.0 → 0.2.3

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## 0.2.3 — removable dsh-ops coexistence bridge
+
+- Moved the bridge, profile-patch ownership, and pure name planning into `lib/dsh-ops-bridge.js`.
+  `index.js` now mounts it in one place; `package.json` ships the module.
+- Enabled coexistence declaratively from `cordis.patch.yml`; the plugin no longer writes an
+  enable override into the profile. Turning the switch off writes only a marked disable override.
+- Removal contract: delete the module, the mount line, the config field, the client switch, and its
+  gate; the bundle patch disappears with the package. A switch-off override is the only possible
+  profile residue and is removed by the plugin's cleanup when it runs.
+- The bundle patch must come after `dsh-ops` in `dsh.profile.bundles`; otherwise the loader warns
+  and skips it. The profile keeps `dsh-ops` before `dsh-win-pwsh7`.
+
+## 0.2.2 — fix the dsh-ops bridge freeze
+
+- Fixed the 0.2.1 hide/unhide oscillation that could pin the Host main thread when many sessions
+  were restored. The bridge now plans from the host's **pre-restriction** `knownNames` /
+  `restrictableNames` instead of the post-restriction `visible` set, and filters the deny list to
+  names `tools.restrict()` actually accepts. The fallback path latches names it already hid.
+- Added regression checks for the stable plan, the older-host fallback, and the scope-local
+  `ops_bash` case that used to throw an unknown-global-tool warning.
+- Restored `dshOpsCompat` to default-on after multi-session validation of the fixed bridge.
+- The configuration page now uses the native `Switch` primitive and native setting-row layout for
+  the coexistence toggle; labels and hints no longer expose raw config keys.
+
+## 0.2.1 — dsh-ops coexistence bridge
+
+- Added a default-on `dshOpsCompat` configuration row. When dsh-ops is installed, pwsh7 writes
+  a marked `dsh-ops-compat` override into the active profile patch and enables it, so the native
+  `pwsh` tool is visible again alongside `ops_bash`.
+- The agent bridge re-hides the official `read` / `glob` / `grep` tools when their OPS
+  counterparts are visible, plus the duplicate official `bash` / `pwsh_persistent` shell. It
+  keeps `pwsh` and `ops_bash` and does nothing when dsh-ops is absent.
+- The compatibility patch needs a DSH restart; turning the switch off removes only the block this
+  plugin wrote. Uninstall cleanup is best-effort and leaves at most a harmless compatibility row.
+- Added the plugin-page toggle with its own localized row and hint.
+
 ## 0.2.0 — 优化 Store 版 pwsh7 安装方式
 
 优化store版pwsh7安装方式，重构项目前端设计和工程设计，使其符合原生DSH工程习惯和界面风格。

package/README.en.md

@@ -25,14 +25,26 @@ default executor then chooses the runtime itself, and the plugin still never wri
 ## What it does not do
 
 - It does not install anything at startup.
-- It does not write the executor's `pwshPath` or edit the profile patch.
+- It does not write the executor's `pwshPath`; it only writes a marked dsh-ops compatibility override when coexistence is on.
 - It does not uninstall a Store-installed PowerShell 7.
 - It does not auto-detect VPNs or preflight metered connections.
 
+## Coexistence with dsh-ops
+
+On by default. The `dsh-ops-compat` override in `cordis.patch.yml` owns the enabled state: while
+the dsh-win-pwsh7 bundle is installed and comes after dsh-ops, a DSH restart restores the native
+`pwsh` tool and keeps `ops_bash`. Turning the switch off writes only a marked disable override;
+removing the bundle removes the enable override, and cleanup best-effort removes the disable one.
+
+The 0.2.1 bridge planned from the post-restriction visible set, which made it hide and restore the
+same tools in a loop and starved the Host main thread. 0.2.2 plans from the pre-restriction
+`knownNames` / `restrictableNames` and filters names `tools.restrict()` does not accept. The
+multi-session validation passed, so the switch is default-on again.
+
 ## Install this plugin
 
 ```powershell
-dsh plugin --profile desktop add github:XinSpark/dsh-win-pwsh7#v0.2.0
+dsh plugin --profile desktop add github:XinSpark/dsh-win-pwsh7#v0.2.3
 # or
 dsh plugin --profile desktop add dsh-win-pwsh7
 ```
@@ -70,6 +82,7 @@ The count lives in the current process and resets when DSH restarts.
 | Key | Default | Meaning |
 |---|---|---|
 | `overridePath` | unset | Priority ① explicit `pwsh.exe`. It must spawn and report PowerShell 7+; a failed validation falls back to auto-detection. **It only changes probing and recommendations, not executor wiring.** |
+| `dshOpsCompat` | `true` | Coexist with dsh-ops (on by default): writes and enables its Compatibility mode, hides duplicate official tools, and keeps `pwsh` + `ops_bash`. Requires a restart. |
 
 `overridePath` is `volatile()`: the plugin-page configuration section saves it live; it can also be
 set in the profile patch:
@@ -113,7 +126,8 @@ executor / disable the plugin.
 ## Plugin page
 
 The status section is a native card showing the state, runtime and executor path, with Re-detect
-at the top right; the configuration section exposes only `overridePath`.
+at the top right; the configuration section exposes `overridePath` and the default-on "Keep native
+pwsh alongside dsh-ops" native switch.
 
 ## Disable or uninstall
 

package/README.md

@@ -20,15 +20,23 @@
 ## 它不做什么
 
 - 不在启动时自动安装。
-- 不写执行器的 `pwshPath`，也不修改 profile 补丁。
+- 不写执行器的 `pwshPath`；只会在开启共存时写一条带标记的 dsh-ops 兼容覆盖。
 - 不卸载由 Store 安装的 PowerShell 7。
 - 不做 VPN 自动检测，也不做计量连接预检。
 
+## 与 dsh-ops 共存
+
+默认开启。启用由 `cordis.patch.yml` 的声明式 `dsh-ops-compat` 覆盖负责：只要 dsh-win-pwsh7 的 bundle 安装且位于 dsh-ops 之后，重启 DSH 后官方 `pwsh` 恢复，`ops_bash` 保留。关闭开关时只写入一条带标记的 disable override；卸载 bundle 后启用覆盖消失，cleanup 会尽力删除 disable override。
+
+0.2.1 的桥接层在计算隐藏集合时读取了限制后的可见工具，会在隐藏/恢复之间振荡并卡死宿主；0.2.2 改为读取限制前的 `knownNames` / `restrictableNames`，并过滤 `tools.restrict()` 不接受的名字。多会话验证通过后已恢复默认开启。
+
+桥接层还会在对应 OPS 工具可见时隐藏官方 `read` / `glob` / `grep`，以及重复的官方 `bash` / `pwsh_persistent`，让工具面保持 `pwsh` + `ops_bash`。桥接实现独立在 `lib/dsh-ops-bridge.js`，删除该模块和入口挂载即可移除。
+
 ## 安装本插件
 
 ```powershell
 # 从 GitHub 安装（推荐锁定 tag）
-dsh plugin --profile desktop add github:XinSpark/dsh-win-pwsh7#v0.2.0
+dsh plugin --profile desktop add github:XinSpark/dsh-win-pwsh7#v0.2.3
 # 或 npm
 dsh plugin --profile desktop add dsh-win-pwsh7
 ```
@@ -61,6 +69,7 @@ dsh plugin --profile desktop add dsh-win-pwsh7
 | 键 | 默认 | 说明 |
 |---|---|---|
 | `overridePath` | 未设 | 优先级①的显式 `pwsh.exe`。必须能启动并报告 PowerShell 7+；未通过校验就回落到自动探测。**只影响探测与推荐，不接线**。 |
+| `dshOpsCompat` | `true` | 与 dsh-ops 共存（默认开启）：自动写入并启用兼容模式，隐藏重复的官方工具，保留 `pwsh` + `ops_bash`。需要重启。 |
 
 `overridePath` 是 `volatile()`：插件页配置区保存即生效；也可以写进 profile 补丁：
 
@@ -96,7 +105,7 @@ The executor resolves to the version-stable Store family alias: … Nothing to c
 
 ## 插件页
 
-插件页的状态区是原生卡片，显示状态、运行时和执行器路径，右上角有「重新检测」；配置区只有 `overridePath`。
+插件页的状态区是原生卡片，显示状态、运行时和执行器路径，右上角有「重新检测」；配置区有 `overridePath` 和默认开启的「与 dsh-ops 共存」原生开关。
 
 ## 禁用或卸载
 

package/client.js

@@ -12,6 +12,7 @@ window.__ModuleLoader__.load({
   id: 'dsh-win-pwsh7',
   factory(require) {
     const React = require('react')
+    const { Switch } = require('@deepseek-ai/dsh-client-ui-primitives')
     const h = React.createElement
     const { useEffect, useState, useSyncExternalStore } = React
 
@@ -96,8 +97,10 @@ window.__ModuleLoader__.load({
       redetect: 'Re-detect',
       redetecting: 'Detecting…',
       card_title: 'Configuration',
-      field_overridePath: 'Explicit path (overridePath)',
-      overridePath_hint: 'Priority ① explicit pwsh.exe path. Empty = auto-detect. It must spawn and report PowerShell 7 or newer; the Store family alias is accepted, while a version-numbered Store path is never pinned. This only changes what the plugin probes and recommends — it does not wire the pwsh tool. Use the patch in the status section for that.',
+      field_overridePath: 'PowerShell 7 path',
+      overridePath_hint: 'Optional explicit pwsh.exe path (`overridePath`). Empty = auto-detect. It must spawn and report PowerShell 7 or newer; the Store family alias is accepted, while a version-numbered Store path is never pinned. This only changes what the plugin probes and recommends — it does not wire the pwsh tool. Use the patch in the status section for that.',
+      field_dshOpsCompat: 'Coexist with dsh-ops',
+      dshOpsCompat_hint: 'On by default. Keeps the native pwsh tool beside ops_bash by enabling dsh-ops Compatibility and hiding its duplicate official tools. Requires a DSH restart.',
       save: 'Save',
       reset: 'Reset',
       saved: 'Saved {at}',
@@ -138,8 +141,10 @@ window.__ModuleLoader__.load({
       redetect: '重新检测',
       redetecting: '检测中…',
       card_title: '配置',
-      field_overridePath: '指定路径（overridePath）',
-      overridePath_hint: '优先级①的显式 pwsh.exe 路径。留空 = 自动探测。必须能启动并报告 PowerShell 7 及以上；Store 家族别名可用，版本号目录永不被 pin。这里只影响插件的探测与推荐，不会给 pwsh 工具接线；接线请用状态区里的补丁。',
+      field_overridePath: 'PowerShell 7 路径',
+      overridePath_hint: '可选的显式 pwsh.exe 路径（`overridePath`）。留空 = 自动探测。必须能启动并报告 PowerShell 7 及以上；Store 家族别名可用，版本号目录永不被 pin。这里只影响插件的探测与推荐，不会给 pwsh 工具接线；接线请用状态区里的补丁。',
+      field_dshOpsCompat: '与 dsh-ops 共存',
+      dshOpsCompat_hint: '默认开启。通过启用 dsh-ops 的 Compatibility 模式并隐藏重复的官方工具，让原生 pwsh 与 ops_bash 并存。需要重启 DSH。',
       save: '保存',
       reset: '重置',
       saved: '已保存 {at}',
@@ -181,6 +186,8 @@ window.__ModuleLoader__.load({
 .dw7-input:focus-visible{outline:none;border-color:var(--dsw-alias-state-business-primary);}
 .dw7-input:disabled{color:var(--dsw-alias-label-tertiary);cursor:default;}
 .dw7-hint{margin:0;color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:1.5;}
+.dw7-switch-row{display:flex;align-items:flex-start;gap:16px;min-width:0;}
+.dw7-switch-text{flex:1 1 auto;min-width:0;display:flex;flex-direction:column;gap:4px;}
 .dw7-actions{display:flex;align-items:center;gap:8px;flex-wrap:wrap;padding-top:4px;}
 .dw7-save{appearance:none;border:1px solid transparent;border-radius:var(--dsw-radius-md);padding:5px 14px;font:inherit;font-size:13px;line-height:1.5;cursor:pointer;background:var(--dsw-alias-label-primary);color:var(--dsw-alias-bg-layer-3);}
 .dw7-save:disabled{opacity:.4;cursor:default;}
@@ -415,9 +422,10 @@ window.__ModuleLoader__.load({
           const unavailable = snap.status === 'unavailable'
           const served = {
             overridePath: typeof snap.value?.overridePath === 'string' ? snap.value.overridePath : '',
+            dshOpsCompat: snap.value?.dshOpsCompat !== false,
           }
           const values = draft ?? served
-          const dirty = draft !== null && values.overridePath !== served.overridePath
+          const dirty = draft !== null && (values.overridePath !== served.overridePath || values.dshOpsCompat !== served.dshOpsCompat)
           const editable = !loading && !unavailable && snap.writable !== false && !busy
 
           async function save() {
@@ -431,6 +439,9 @@ window.__ModuleLoader__.load({
               } else if (nextPath !== served.overridePath) {
                 ok = await form.set('overridePath', nextPath) && ok
               }
+              if (values.dshOpsCompat !== served.dshOpsCompat) {
+                ok = await form.set('dshOpsCompat', values.dshOpsCompat) && ok
+              }
               if (ok) {
                 setDraft(null)
                 setSavedAt(new Date().toLocaleTimeString())
@@ -462,12 +473,27 @@ window.__ModuleLoader__.load({
                     disabled: !editable,
                     placeholder: 'C:\\Program Files\\PowerShell\\7\\pwsh.exe',
                     onChange: (event) => {
-                      setDraft({ overridePath: event.target.value })
+                      setDraft({ ...values, overridePath: event.target.value })
                       setNote(null)
                       setSavedAt(null)
                     },
                   }),
                   h('p', { className: 'dw7-hint' }, t('overridePath_hint'))),
+                h('div', { className: 'dw7-field', key: 'dshOpsCompat' },
+                  h('div', { className: 'dw7-switch-row' },
+                    h('div', { className: 'dw7-switch-text' },
+                      h('div', { className: 'dw7-label' }, t('field_dshOpsCompat')),
+                      h('p', { className: 'dw7-hint' }, t('dshOpsCompat_hint'))),
+                    h(Switch, {
+                      checked: values.dshOpsCompat,
+                      disabled: !editable,
+                      label: t('field_dshOpsCompat'),
+                      onChange: (checked) => {
+                        setDraft({ ...values, dshOpsCompat: checked })
+                        setNote(null)
+                        setSavedAt(null)
+                      },
+                    }))),
                 h('div', { className: 'dw7-actions', key: 'actions' },
                   h('button', {
                     className: 'dw7-save',

package/cordis.patch.yml

@@ -4,3 +4,9 @@
 - insert:
     - id: win-pwsh7
       name: dsh-win-pwsh7
+# Coexistence override: keep dsh-ops Compatibility on while this bundle is installed. The
+# loader warns and skips the override when dsh-ops is absent; the profile switch writes the
+# matching disable row only when the user turns coexistence off.
+- id: dsh-ops-compat
+  name: dsh-ops/compat
+  disabled: false

package/index.js

@@ -46,6 +46,11 @@ import { Service } from '@deepseek-ai/cordis'
 import { defineTool } from '@deepseek-ai/dsh-tools'
 import { resolvePwshPath } from '@deepseek-ai/dsh-pwsh-local'
 import z from '@deepseek-ai/schemastery'
+import {
+  ensureDshOpsCompat,
+  mountDshOpsBridge,
+  removeDshOpsCompatPatch,
+} from './lib/dsh-ops-bridge.js'
 
 export const name = 'dsh-win-pwsh7'
 export const inject = ['subprocess', 'tools', 'configEditor', 'systemPrompt']
@@ -58,9 +63,13 @@ export const inject = ['subprocess', 'tools', 'configEditor', 'systemPrompt']
  * - id: win-pwsh7
  *   config:
  *     overridePath: 'D:\tools\pwsh\pwsh.exe'   # priority ① — validated, must be an ordinary PowerShell 7+
+ *     dshOpsCompat: true                          # default; keeps pwsh beside dsh-ops ops_bash
  */
 export const Config = z.object({
   overridePath: z.string().volatile(),
+  // Default-on after the multi-session validation of the pre-restriction bridge. Turning it
+  // off removes the managed compatibility override; turning it on restores it.
+  dshOpsCompat: z.boolean().default(true).volatile(),
 })
 
 /**
@@ -343,6 +352,27 @@ export function apply(ctx, config) {
   const current = () => readRowConfig(ctx, config)
   hostContext = ctx
   const state = runtimeState(ctx)
+  const syncCompat = () => {
+    void ensureDshOpsCompat(ctx, current()).then((result) => {
+      if (result.changed) {
+        const action = result.state === 'bundle'
+          ? 'delegated to the bundle patch'
+          : result.state === 'legacy-order'
+            ? 'kept as a profile fallback because the bundle order is reversed'
+            : result.state === 'disabled' ? 'disabled in the profile' : 'removed'
+        ctx.logger?.info?.('dsh-win-pwsh7: dsh-ops compatibility %s; restart DSH to apply', action)
+      }
+    }, (error) => {
+      ctx.logger?.warn?.('dsh-win-pwsh7: dsh-ops compatibility patch failed: %s', describe(error))
+    })
+  }
+
+  ctx.effect(() => {
+    syncCompat()
+    return () => { removeDshOpsCompatPatch(ctx) }
+  }, 'dsh-win-pwsh7: manage the dsh-ops compatibility patch')
+
+  ctx.effect(() => mountDshOpsBridge(ctx, current), 'dsh-win-pwsh7: hide duplicate official tools while dsh-ops is compatible')
 
   ctx.effect(() => {
     void activationSweep(ctx, current()).then((report) => {
@@ -473,8 +503,8 @@ export function apply(ctx, config) {
   ctx.effect(() => {
     if (typeof ctx.on !== 'function') return
     const disposers = [
-      ctx.on('app-boot/config-reload', () => { void refreshGate(ctx, current()) }),
-      ctx.on('plugin-manager/changed', () => { void refreshGate(ctx, current()) }),
+      ctx.on('app-boot/config-reload', () => { void refreshGate(ctx, current()); syncCompat() }),
+      ctx.on('plugin-manager/changed', () => { void refreshGate(ctx, current()); syncCompat() }),
     ]
     return () => {
       for (const dispose of disposers) dispose?.()
@@ -502,11 +532,13 @@ let hostContext = null
 function readRowConfig(ctx, fallback) {
   const merged = {
     overridePath: typeof fallback?.overridePath === 'string' ? fallback.overridePath : undefined,
+    dshOpsCompat: fallback?.dshOpsCompat !== false,
   }
   try {
     const entry = ctx.configEditor.entries().find((candidate) => candidate?.options?.name === 'dsh-win-pwsh7')
     const values = entry?.options?.config
     if (isSet(values?.overridePath)) merged.overridePath = String(values.overridePath)
+    if (values?.dshOpsCompat !== undefined) merged.dshOpsCompat = values.dshOpsCompat !== false
   } catch { /* fall back to the captured config */ }
   return merged
 }

package/lib/dsh-ops-bridge.js

@@ -0,0 +1,329 @@
+/**
+ * Optional dsh-ops coexistence bridge.
+ *
+ * The bundle patch declares the compatibility override; this module only owns the switch-off
+ * override and the agent-scoped hiding of duplicate official tools. Keeping the enable path
+ * declarative is what makes the feature removable with the bundle.
+ */
+import { readFileSync, renameSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+const isSet = (value) => typeof value === 'string' && value.length > 0
+const describe = (error) => error instanceof Error ? error.message : String(error)
+
+/** Markers for the only profile blocks this plugin may own. */
+const DSH_OPS_PATCH_MARKER = '# dsh-win-pwsh7: dsh-ops compatibility (managed)'
+const DSH_OPS_PATCH_BLOCK = `${DSH_OPS_PATCH_MARKER}\n- id: dsh-ops-compat\n  disabled: false\n`
+const DSH_OPS_DISABLE_MARKER = '# dsh-win-pwsh7: dsh-ops compatibility disabled (managed)'
+const DSH_OPS_DISABLE_BLOCK = `${DSH_OPS_DISABLE_MARKER}\n- id: dsh-ops-compat\n  disabled: true\n`
+
+/**
+ * The active profile directory. DSH exposes it to profile-launched processes; the
+ * plugin-manager instance carries the same directory as a fallback for hosts that do not.
+ * @param ctx - the row's Host context.
+ * @returns the profile directory, or `undefined` when it cannot be established safely.
+ */
+function profileDirectory(ctx) {
+  if (isSet(process.env.DSH_PROFILE_DIR)) return process.env.DSH_PROFILE_DIR
+  const manager = ctx.get('pluginManager')
+  const directory = manager?.profile?.dir
+  return isSet(directory) ? directory : undefined
+}
+
+/**
+ * Whether dsh-ops is installed in this profile, read through the plugin manager's public
+ * bundle view. A missing manager or an unreadable view is "not detected", never an error.
+ * @param ctx - the row's Host context.
+ * @returns true when the dsh-ops bundle is present.
+ */
+async function dshOpsInstalled(ctx) {
+  const manager = ctx.get('pluginManager')
+  if (manager === undefined || typeof manager.listBundles !== 'function') return false
+  try {
+    const bundles = await manager.listBundles()
+    const ops = Array.isArray(bundles)
+      ? bundles.find((bundle) => bundle?.name === 'dsh-ops' && bundle.installed !== false)
+      : undefined
+    return ops !== undefined && Array.isArray(ops.rows) && ops.rows.some((row) => row?.moduleName === 'dsh-ops/compat')
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Whether dsh-ops is layered before dsh-win-pwsh7. The bundle override can only target a row
+ * inserted by an earlier layer; a reversed order would be warned and skipped by the loader.
+ * @param ctx - the row's Host context.
+ * @returns true when the order is usable or cannot be established.
+ */
+function bundleOrderOk(ctx) {
+  const directory = profileDirectory(ctx)
+  if (directory === undefined) return true
+  try {
+    const manifest = JSON.parse(readFileSync(join(directory, 'package.json'), 'utf8'))
+    const bundles = manifest?.dsh?.profile?.bundles
+    if (!Array.isArray(bundles)) return true
+    const ops = bundles.indexOf('dsh-ops')
+    const pwsh7 = bundles.indexOf('dsh-win-pwsh7')
+    return ops < 0 || pwsh7 < 0 || ops < pwsh7
+  } catch {
+    return true
+  }
+}
+
+/**
+ * Read and rewrite the profile patch atomically; a failed write leaves the previous file.
+ * @param path - the profile patch file.
+ * @param transform - receives the current text and returns the next text.
+ * @returns true when the file changed.
+ */
+function rewriteProfilePatch(path, transform) {
+  let current = ''
+  try {
+    current = readFileSync(path, 'utf8')
+  } catch {
+    current = ''
+  }
+  const next = transform(current)
+  if (next === current) return false
+  const temporary = `${path}.${process.pid}.tmp`
+  writeFileSync(temporary, next, 'utf8')
+  renameSync(temporary, path)
+  return true
+}
+
+/**
+ * Remove the marked block only; a user's own `dsh-ops-compat` override is not touched.
+ * @param text - the profile patch text.
+ * @returns the text without this plugin's block.
+ */
+function withoutCompatBlock(text) {
+  return text
+    .replace(/# dsh-win-pwsh7: dsh-ops compatibility \(managed\)\r?\n- id: dsh-ops-compat\r?\n  disabled: false\r?\n?/u, '')
+    .replace(/# dsh-win-pwsh7: dsh-ops compatibility disabled \(managed\)\r?\n- id: dsh-ops-compat\r?\n  disabled: true\r?\n?/u, '')
+}
+
+/** Whether the user already owns a dsh-ops-compat override outside our markers. */
+function hasForeignCompatEntry(text) {
+  return /^\s*-\s*(?:\{\s*)?id:\s*['"]?dsh-ops-compat\b/mu.test(withoutCompatBlock(text))
+}
+
+/**
+ * Ensure the bundle owns the enabled state, and the profile owns only an explicit switch-off.
+ * @param ctx - the row's Host context.
+ * @param config - the live row configuration.
+ * @returns `{ changed, state }` for logging; never throws.
+ */
+export async function ensureDshOpsCompat(ctx, config) {
+  const directory = profileDirectory(ctx)
+  if (directory === undefined) return { changed: false, state: 'no-profile' }
+  const path = join(directory, 'cordis.patch.yml')
+  const installed = await dshOpsInstalled(ctx)
+  const enabled = config?.dshOpsCompat !== false
+  if (!installed) {
+    return { changed: rewriteProfilePatch(path, (text) => withoutCompatBlock(text)), state: 'not-installed' }
+  }
+  if (enabled) {
+    if (bundleOrderOk(ctx)) {
+      // The bundle patch enables compatibility. Remove only legacy managed blocks so an old
+      // profile does not keep a duplicate override; a user's own entry is untouched.
+      const changed = rewriteProfilePatch(path, (text) => {
+        if (!text.includes(DSH_OPS_PATCH_MARKER) && !text.includes(DSH_OPS_DISABLE_MARKER)) return text
+        return withoutCompatBlock(text)
+      })
+      return { changed, state: 'bundle' }
+    }
+    // Older/foreign profiles can list pwsh7 before dsh-ops; the bundle override would be
+    // skipped. Keep the legacy profile enable block as a working fallback.
+    const changed = rewriteProfilePatch(path, (text) => {
+      if (hasForeignCompatEntry(text)) return text
+      if (text.includes(DSH_OPS_PATCH_MARKER)) return text
+      const base = withoutCompatBlock(text)
+      const normalized = base.trim() === '[]' ? '' : base
+      const separator = normalized === '' || normalized.endsWith('\n') ? '' : '\n'
+      return `${normalized}${separator}${DSH_OPS_PATCH_BLOCK}`
+    })
+    return { changed, state: 'legacy-order' }
+  }
+  const changed = rewriteProfilePatch(path, (text) => {
+    // Respect a user-owned override instead of fighting it with a second id.
+    if (hasForeignCompatEntry(text)) return withoutCompatBlock(text)
+    if (text.includes(DSH_OPS_DISABLE_MARKER)) return text
+    const base = withoutCompatBlock(text)
+    const normalized = base.trim() === '[]' ? '' : base
+    const separator = normalized === '' || normalized.endsWith('\n') ? '' : '\n'
+    return `${normalized}${separator}${DSH_OPS_DISABLE_BLOCK}`
+  })
+  return { changed, state: 'disabled' }
+}
+
+/** Synchronous best-effort removal for plugin disposal and config changes. */
+export function removeDshOpsCompatPatch(ctx) {
+  const directory = profileDirectory(ctx)
+  if (directory === undefined) return false
+  try {
+    return rewriteProfilePatch(join(directory, 'cordis.patch.yml'), (text) => withoutCompatBlock(text))
+  } catch (error) {
+    ctx.logger?.warn?.('dsh-win-pwsh7: could not remove the dsh-ops compatibility patch: %s', describe(error))
+    return false
+  }
+}
+
+/**
+ * The tool-name facts of one agent, read from the host's pre-restriction view when it is
+ * available.
+ *
+ * `visible` is POST-restriction: hiding read/glob/grep removes them from it, so the next
+ * reconcile pass no longer saw a counterpart pair, lifted the mask, saw the pair again, and
+ * restored it. Each flip emitted `tools/change`, which called this reconcile again — an
+ * endless hide/unhide loop that starved the Host main thread once many agents were created.
+ * `knownNames` / `restrictableNames` keep the pre-restriction facts and are also the only
+ * names `tools.restrict()` accepts, so the deny list is stable and valid.
+ * @param tools - the tool registry.
+ * @param agent - the agent scope.
+ * @param previousDeny - names this bridge already hid, used to keep older hosts stable.
+ * @returns `{ names, restrictable }`, both empty when the surface cannot be read.
+ */
+export function toolNameFacts(tools, agent, previousDeny = []) {
+  try {
+    const view = tools.view?.(agent)
+    const known = view?.knownNames
+    if (known !== undefined && typeof known.has === 'function') {
+      const restrictable = view?.restrictableNames
+      const facts = {
+        names: new Set(known),
+        restrictable: new Set(restrictable !== undefined && typeof restrictable.has === 'function' ? restrictable : known),
+      }
+      for (const name of previousDeny) {
+        facts.names.add(name)
+        facts.restrictable.add(name)
+      }
+      return facts
+    }
+    // Older hosts expose only the visible map or the schema projection. It is
+    // post-restriction, but unioning the names this bridge already hid keeps a
+    // hide/unhide loop from forming in the fallback path too.
+    const visible = view?.visible
+    let names
+    if (visible !== undefined && typeof visible.keys === 'function') {
+      names = new Set(visible.keys())
+    } else {
+      const schemas = tools.schemas?.(agent)
+      names = new Set(Array.isArray(schemas) ? schemas.map((schema) => schema.name) : [])
+    }
+    for (const name of previousDeny) names.add(name)
+    return { names, restrictable: new Set(names) }
+  } catch {
+    return { names: new Set(), restrictable: new Set() }
+  }
+}
+
+/**
+ * The official tools this bridge re-hides when their OPS counterparts are visible. The
+ * counterpart test is deliberate: without it the bridge would hide official tools on a
+ * machine where dsh-ops is absent or Compatibility is off. Candidates are filtered to the
+ * names the host will actually accept in `tools.restrict()`, so a scope-local name such as
+ * a session-owned `ops_bash` can never make the whole mask throw.
+ * @param facts - the agent's stable tool-name facts.
+ * @returns the official names to deny.
+ */
+export function bridgeDenyNames(facts) {
+  const { names } = facts
+  const deny = []
+  if (names.has('ops_inspect_local_file') && names.has('read')) deny.push('read')
+  if (names.has('ops_glob') && names.has('glob')) deny.push('glob')
+  if (names.has('ops_grep') && names.has('grep')) deny.push('grep')
+  if (names.has('ops_bash')) {
+    if (names.has('bash')) deny.push('bash')
+    // Compatibility would otherwise expose both PowerShell tools beside ops_bash; keep
+    // the ordinary `pwsh` and remove the persistent duplicate.
+    if (names.has('pwsh') && names.has('pwsh_persistent')) deny.push('pwsh_persistent')
+  }
+  return deny.filter((name) => facts.restrictable.has(name))
+}
+
+/**
+ * Keep the official file tools and duplicate shell out of the model's view when dsh-ops
+ * Compatibility is on. Agent-scoped `tools.restrict` is the only seam that hides rather
+ * than denies; every mask is lifted with its agent or with this effect.
+ * @param ctx - the row's Host context.
+ * @param current - reads the live row configuration.
+ * @returns a disposer for the bridge.
+ */
+export function mountDshOpsBridge(ctx, current) {
+  if (typeof ctx.on !== 'function') return
+  const tools = ctx.tools ?? ctx.get('tools')
+  const agents = ctx.get('agents')
+  if (tools === undefined || agents === undefined || typeof tools.restrict !== 'function') return
+  const entries = new Map()
+  let stopped = false
+  let mutating = false
+  const lift = (entry) => {
+    entry.deny = []
+    for (const dispose of entry.lifts.splice(0)) {
+      try {
+        dispose?.()
+      } catch (error) {
+        ctx.logger?.warn?.('dsh-win-pwsh7: bridge restriction cleanup failed: %s', describe(error))
+      }
+    }
+  }
+  const reconcile = () => {
+    if (stopped || mutating) return
+    mutating = true
+    try {
+      const enabled = current()?.dshOpsCompat !== false
+      if (!enabled) {
+        for (const entry of entries.values()) lift(entry)
+        entries.clear()
+        return
+      }
+      for (const agent of agents.list?.() ?? []) {
+        if (!entries.has(agent)) entries.set(agent, { lifts: [], deny: [] })
+      }
+      for (const [agent, entry] of entries) {
+        const deny = bridgeDenyNames(toolNameFacts(tools, agent, entry.deny))
+        if (deny.length === entry.deny.length && deny.every((name) => entry.deny.includes(name))) continue
+        lift(entry)
+        if (deny.length === 0) continue
+        try {
+          if (agent?.ctx?.tools === undefined) continue
+          entry.lifts.push(agent.ctx.tools.restrict({ deny }))
+          entry.deny = deny
+        } catch (error) {
+          ctx.logger?.warn?.('dsh-win-pwsh7: bridge could not hide %s: %s', deny.join(', '), describe(error))
+        }
+      }
+    } finally {
+      mutating = false
+    }
+  }
+  const disposers = []
+  if (typeof ctx.on === 'function') {
+    disposers.push(ctx.on('agent/created', ({ agent } = {}) => {
+      if (agent !== undefined) entries.set(agent, { lifts: [], deny: [] })
+      reconcile()
+    }))
+    disposers.push(ctx.on('agent/disposed', ({ agent } = {}) => {
+      const entry = entries.get(agent)
+      if (entry !== undefined) {
+        lift(entry)
+        entries.delete(agent)
+      }
+    }))
+    disposers.push(ctx.on('tools/change', () => { reconcile() }))
+    disposers.push(ctx.on('system-prompt/assemble', async (_assembly, _context, next) => {
+      reconcile()
+      return next()
+    }))
+    disposers.push(ctx.on('app-boot/config-reload', () => { reconcile() }))
+    disposers.push(ctx.on('plugin-manager/changed', () => { reconcile() }))
+  }
+  reconcile()
+  return () => {
+    stopped = true
+    for (const dispose of disposers) dispose?.()
+    for (const entry of entries.values()) lift(entry)
+    entries.clear()
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-win-pwsh7",
-  "version": "0.2.0",
+  "version": "0.2.3",
   "type": "module",
   "description": "Detect and validate PowerShell 7 for the Harness pwsh tool on Windows, and install it on request through the Microsoft Store — scripted or manual — while the pwsh tool stays blocked until a PowerShell 7 runtime actually resolves.",
   "engines": {
@@ -32,6 +32,7 @@
     "index.js",
     "client.js",
     "lib/typert.host.js",
+    "lib/dsh-ops-bridge.js",
     "cordis.patch.yml",
     "locale/*.json",
     "icon.svg",
@@ -64,7 +65,8 @@
       "immediately": true,
       "inject": [
         "@deepseek-ai/dsh-client-ui-plugin-manager",
-        "@deepseek-ai/dsh-api-remotes"
+        "@deepseek-ai/dsh-api-remotes",
+        "@deepseek-ai/dsh-client-ui-primitives"
       ]
     }
   }

package/tools/check-client.mjs

@@ -38,6 +38,18 @@ const React = {
   },
 }
 
+/** The native Switch primitive, rendered as the button role the real component uses. */
+function Switch({ checked, onChange, label, disabled }) {
+  return React.createElement('button', {
+    type: 'button',
+    role: 'switch',
+    'aria-checked': checked,
+    'aria-label': label,
+    disabled,
+    onClick: () => onChange(!checked),
+  })
+}
+
 /** Every string rendered anywhere in the tree, in document order. */
 function textsOf(node, found = []) {
   if (typeof node === 'string' || typeof node === 'number') {
@@ -119,6 +131,7 @@ await import('../client.js')
 assert.ok(entry !== undefined, 'client.js did not call window.__ModuleLoader__.load()')
 const client = entry.factory((name) => {
   if (name === 'react') return React
+  if (name === '@deepseek-ai/dsh-client-ui-primitives') return { Switch }
   throw new Error(`the client half required an unexpected module: ${name}`)
 })
 client.apply(ctx)
@@ -141,24 +154,22 @@ const cardTree = card({ view: 'page' })
 const cardTexts = textsOf(cardTree)
 
 check('the card renders its labels from the dictionaries, never as bare config keys', () => {
-  for (const key of ['overridePath']) {
+  for (const key of ['overridePath', 'dshOpsCompat']) {
     assert.ok(!cardTexts.includes(key),
       `the card rendered the bare config key "${key}" — a label was written as a literal instead of t()`)
   }
-  for (const expected of [dictionaries.zh.field_overridePath]) {
+  for (const expected of [dictionaries.zh.field_overridePath, dictionaries.zh.field_dshOpsCompat]) {
     assert.ok(cardTexts.includes(expected), `the card does not render the label "${expected}"`)
   }
 })
-check('each field label also keeps its raw config key, so the form maps to cordis.patch.yml', () => {
-  const labels = elementsOf(cardTree, 'label').map((element) => textsOf(element).join(''))
-  assert.equal(labels.length, 1, `expected one label, found ${labels.length}`)
-  for (const [index, key] of ['overridePath'].entries()) {
-    assert.match(labels[index], new RegExp(key, 'u'), `label ${index} drops the raw key ${key}`)
-    assert.match(labels[index], /[\u4e00-\u9fff]/u, `label ${index} is not localized: ${labels[index]}`)
-  }
+check('the coexist row uses the native Switch primitive, not a custom checkbox', () => {
+  const switches = elementsOf(cardTree, Switch)
+  assert.equal(switches.length, 1, `expected one native switch, found ${switches.length}`)
+  assert.equal(switches[0].props.checked, true)
+  assert.equal(switches[0].props.label, dictionaries.zh.field_dshOpsCompat)
 })
 check('the card renders every hint in Chinese', () => {
-  for (const hint of [dictionaries.zh.overridePath_hint]) {
+  for (const hint of [dictionaries.zh.overridePath_hint, dictionaries.zh.dshOpsCompat_hint]) {
     assert.ok(cardTexts.includes(hint), `the card does not render the hint "${hint.slice(0, 24)}…"`)
   }
 })

package/tools/check-host.mjs

@@ -12,7 +12,7 @@
  * from a table; the install checks run the job body against that stub, never Microsoft Store.
  */
 import { register } from 'node:module'
-import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync } from 'node:fs'
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { tmpdir } from 'node:os'
 import assert from 'node:assert/strict'
@@ -52,6 +52,7 @@ process.env.LOCALAPPDATA = gateHome
 process.env.PATH = join(gateHome, 'bin')
 
 const { apply } = await import('../index.js')
+const { bridgeDenyNames, toolNameFacts } = await import('../lib/dsh-ops-bridge.js')
 
 /** An ordinary executable that exists on every Windows machine; its version comes from the stub. */
 const ORDINARY = 'C:\\Windows\\System32\\cmd.exe'
@@ -78,7 +79,7 @@ function makeStoreFixtures() {
  * A stub Host context: records registrations, prompt sections and job specs, answers probes,
  * spawns nothing. `jobs: false` omits the job registry.
  */
-function makeContext({ rows = [], versions = {}, jobs = false, shellPath, shellObject } = {}) {
+function makeContext({ rows = [], versions = {}, jobs = false, shellPath, shellObject, pluginManager, agents, visible } = {}) {
   const registered = new Map()
   const sections = []
   const orderNames = []
@@ -105,6 +106,8 @@ function makeContext({ rows = [], versions = {}, jobs = false, shellPath, shellO
     plugin() {},
     get: (key) => {
       if (key === 'configForms') return { get: () => ({}) }
+      if (key === 'pluginManager') return pluginManager
+      if (key === 'agents') return agents
       if (key === 'jobs' && jobs) return jobRegistry
       // The pwsh tool executes through `ctx.shell`; the executor's own `pwshPath` is the
       // authoritative "what will run" fact. A context without it keeps the row-based reading.
@@ -129,6 +132,13 @@ function makeContext({ rows = [], versions = {}, jobs = false, shellPath, shellO
           if (index >= 0) guards.splice(index, 1)
         }
       },
+      restrict() { return () => {} },
+      view() {
+        return { visible: new Map((visible ?? []).map((name) => [name, {}])) }
+      },
+      schemas() {
+        return (visible ?? []).map((name) => ({ name }))
+      },
     },
     on(event, listener) {
       const set = listeners.get(event) ?? new Set()
@@ -641,6 +651,150 @@ if (existsSync(MSI)) {
   else process.env.ProgramFiles = savedProgramFiles
 }
 
+// --- dsh-ops compatibility patch ---------------------------------------------------------
+const compatDir = mkdtempSync(join(tmpdir(), 'dsh-win-pwsh7-compat-'))
+const compatPatchPath = join(compatDir, 'cordis.patch.yml')
+writeFileSync(compatPatchPath, '# dsh-win-pwsh7: dsh-ops compatibility (managed)\n- id: dsh-ops-compat\n  disabled: false\n- id: keep-me\n  name: keep-me\n', 'utf8')
+const savedProfileDir = process.env.DSH_PROFILE_DIR
+process.env.DSH_PROFILE_DIR = compatDir
+const compatMachine = makeContext({
+  pluginManager: {
+    async listBundles() {
+      return [{ name: 'dsh-ops', installed: true, rows: [{ moduleName: 'dsh-ops/compat' }] }]
+    },
+  },
+})
+apply(compatMachine.ctx, {})
+await new Promise((resolve) => setTimeout(resolve, 50))
+const compatWritten = readFileSync(compatPatchPath, 'utf8')
+check('the enabled path delegates to the bundle and removes a legacy managed override', () => {
+  assert.ok(!compatWritten.includes('dsh-win-pwsh7: dsh-ops compatibility'), 'a managed block survived')
+  assert.ok(!compatWritten.includes('- id: dsh-ops-compat'), 'the bundle-owned override was written into the profile')
+  assert.match(compatWritten, /- id: keep-me/u, 'the user patch entry was lost')
+})
+apply(compatMachine.ctx, { dshOpsCompat: false })
+await new Promise((resolve) => setTimeout(resolve, 50))
+const compatDisabled = readFileSync(compatPatchPath, 'utf8')
+check('turning coexistence off writes only the managed disable override', () => {
+  assert.match(compatDisabled, /dsh-win-pwsh7: dsh-ops compatibility disabled \(managed\)/u)
+  assert.match(compatDisabled, /- id: dsh-ops-compat\n  disabled: true/u)
+  assert.ok(!compatDisabled.includes('dsh-win-pwsh7: dsh-ops compatibility (managed)'), 'the enable marker survived')
+  assert.ok(compatDisabled.includes('- id: keep-me'), 'the user patch entry was removed')
+})
+apply(compatMachine.ctx, { dshOpsCompat: true })
+await new Promise((resolve) => setTimeout(resolve, 50))
+const compatReenabled = readFileSync(compatPatchPath, 'utf8')
+check('turning coexistence back on removes the disable override for the bundle', () => {
+  assert.ok(!compatReenabled.includes('dsh-win-pwsh7: dsh-ops compatibility'), 'a managed block survived')
+  assert.ok(!compatReenabled.includes('- id: dsh-ops-compat'), 'the bundle-owned override was written into the profile')
+  assert.ok(compatReenabled.includes('- id: keep-me'), 'the user patch entry was removed')
+})
+if (savedProfileDir === undefined) delete process.env.DSH_PROFILE_DIR
+else process.env.DSH_PROFILE_DIR = savedProfileDir
+rmSync(compatDir, { recursive: true, force: true })
+
+check('the bundle patch owns the enabled compatibility override', () => {
+  const patch = readFileSync(new URL('../cordis.patch.yml', import.meta.url), 'utf8')
+  assert.match(patch, /^- id: dsh-ops-compat\n  name: dsh-ops\/compat\n  disabled: false$/mu)
+})
+
+const orderDir = mkdtempSync(join(tmpdir(), 'dsh-win-pwsh7-order-'))
+writeFileSync(join(orderDir, 'package.json'), JSON.stringify({
+  dsh: { profile: { bundles: ['dsh-win-pwsh7', 'dsh-ops'] } },
+}), 'utf8')
+writeFileSync(join(orderDir, 'cordis.patch.yml'), '- id: keep-me\n  name: keep-me\n', 'utf8')
+const savedOrderDir = process.env.DSH_PROFILE_DIR
+process.env.DSH_PROFILE_DIR = orderDir
+const orderMachine = makeContext({
+  pluginManager: {
+    async listBundles() {
+      return [{ name: 'dsh-ops', installed: true, rows: [{ moduleName: 'dsh-ops/compat' }] }]
+    },
+  },
+})
+apply(orderMachine.ctx, {})
+await new Promise((resolve) => setTimeout(resolve, 50))
+const orderPatch = readFileSync(join(orderDir, 'cordis.patch.yml'), 'utf8')
+check('a reversed bundle order keeps the profile fallback instead of silently disabling compatibility', () => {
+  assert.match(orderPatch, /dsh-win-pwsh7: dsh-ops compatibility \(managed\)/u)
+  assert.match(orderPatch, /- id: dsh-ops-compat\n  disabled: false/u)
+  assert.ok(orderPatch.includes('- id: keep-me'))
+})
+if (savedOrderDir === undefined) delete process.env.DSH_PROFILE_DIR
+else process.env.DSH_PROFILE_DIR = savedOrderDir
+rmSync(orderDir, { recursive: true, force: true })
+
+// --- agent bridge hides only the duplicate tools ------------------------------------------
+const bridgeDenies = []
+const bridgeAgent = {
+  ctx: {
+    tools: {
+      restrict({ deny }) {
+        bridgeDenies.push(deny)
+        return () => {}
+      },
+    },
+  },
+}
+const bridgeMachine = makeContext({
+  agents: { list: () => [bridgeAgent] },
+  visible: [
+    'read', 'ops_inspect_local_file',
+    'glob', 'ops_glob',
+    'grep', 'ops_grep',
+    'bash', 'pwsh', 'pwsh_persistent', 'ops_bash',
+  ],
+})
+apply(bridgeMachine.ctx, {})
+check('dsh-ops bridge hides duplicate official tools but keeps pwsh', () => {
+  const deny = bridgeDenies.at(-1) ?? []
+  for (const name of ['read', 'glob', 'grep', 'bash', 'pwsh_persistent']) {
+    assert.ok(deny.includes(name), `bridge did not hide ${name}: ${deny.join(', ')}`)
+  }
+  assert.ok(!deny.includes('pwsh'), 'bridge hid the native pwsh tool')
+  assert.ok(!deny.includes('ops_bash'), 'bridge hid ops_bash')
+})
+
+const bridgeNames = new Set([
+  'read', 'ops_inspect_local_file',
+  'glob', 'ops_glob',
+  'grep', 'ops_grep',
+  'bash', 'pwsh', 'pwsh_persistent', 'ops_bash',
+])
+const bridgeRestrictable = new Set([...bridgeNames].filter((name) => name !== 'ops_bash'))
+const bridgeTools = {
+  view() {
+    return { knownNames: bridgeNames, restrictableNames: bridgeRestrictable }
+  },
+}
+check('the bridge plans from pre-restriction names, so hiding cannot flip it', () => {
+  const first = bridgeDenyNames(toolNameFacts(bridgeTools, {}, []))
+  assert.deepEqual(first, ['read', 'glob', 'grep', 'bash', 'pwsh_persistent'])
+  // `visible` is now post-restriction; knownNames is unchanged, as the host's view guarantees.
+  const second = bridgeDenyNames(toolNameFacts(bridgeTools, {}, first))
+  assert.deepEqual(second, first)
+})
+
+check('the fallback view latches the names already hidden instead of oscillating', () => {
+  const visible = new Set(bridgeNames)
+  const fallbackTools = {
+    view() {
+      return { visible: new Map([...visible].map((name) => [name, {}])) }
+    },
+  }
+  const first = bridgeDenyNames(toolNameFacts(fallbackTools, {}, []))
+  for (const name of first) visible.delete(name)
+  const second = bridgeDenyNames(toolNameFacts(fallbackTools, {}, first))
+  assert.deepEqual(second, first)
+})
+
+check('a scope-local name cannot make the whole restriction plan throw', () => {
+  const facts = toolNameFacts(bridgeTools, {}, [])
+  const deny = bridgeDenyNames({ ...facts, restrictable: new Set([...bridgeRestrictable].filter((name) => name !== 'glob')) })
+  assert.ok(!deny.includes('glob'), 'a non-restrictable name survived the filter')
+  assert.ok(!deny.includes('ops_bash'), 'a scope-local counterpart was put in the deny list')
+})
+
 // --- The client half's policy copy must not drift (static; no browser needed) -------------
 
 const client = readFileSync(new URL('../client.js', import.meta.url), 'utf8')