helloagents 3.0.39 → 3.1.1

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "helloagents",
-  "version": "3.0.39",
+  "version": "3.1.1",
   "description": "HelloAGENTS — The orchestration kernel that makes any AI CLI smarter. Adds intelligent routing, unified QA gates, safety guards, and notifications.",
   "author": {
     "name": "HelloWind",

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "helloagents",
-  "version": "3.0.39",
+  "version": "3.1.1",
   "description": "HelloAGENTS — Quality-driven orchestration kernel for AI CLIs with intelligent routing, unified QA gates, safety guards, and notifications.",
   "author": {
     "name": "HelloWind",

package/README.md

@@ -8,7 +8,7 @@
 
 **A workflow layer for AI coding CLIs: skills, project knowledge, delivery checks, safer config writes, and resumable execution.**
 
-[![Version](https://img.shields.io/badge/version-3.0.39-orange.svg)](./package.json)
+[![Version](https://img.shields.io/badge/version-3.1.1-orange.svg)](./package.json)
 [![npm](https://img.shields.io/npm/v/helloagents.svg)](https://www.npmjs.com/package/helloagents)
 [![Node](https://img.shields.io/badge/node-%3E%3D18-339933.svg)](./package.json)
 [![Skills](https://img.shields.io/badge/skills-14-6366f1.svg)](./skills)
@@ -225,8 +225,10 @@ The CLI manages host files explicitly:
 - `update` refreshes the selected target or all targets
 - `cleanup` removes managed injections and links
 - `uninstall` performs scoped cleanup before package removal
-- `doctor` reports drift in carriers, links, hooks, config entries, plugin roots, cache copies, and versions; for Codex, it also surfaces native `codex doctor` output when available
+- `doctor` reports drift in carriers, links, hooks, config entries, plugin roots, cache copies, versions, and real Claude/Gemini global install artifacts; for Codex, it also surfaces native `codex doctor` output when available
+- Codex managed `notify = ["helloagents-js", "codex-notify"]` stays portable, and `doctor`, `cleanup`, and `uninstall` also recognize wrapped `--previous-notify` chains used by Codex App / Computer Use
 - per-host mode tracking is written only after host setup succeeds, and failed native global cleanup keeps the host tracked as `global` instead of silently layering standby on top
+- Windows `.cmd` / `.bat` lifecycle calls now run through an explicit command wrapper, so host installs, branch switching, and doctor flows do not emit Node `DEP0190` shell deprecation warnings
 
 ## Quick Start
 
@@ -313,7 +315,7 @@ If you omit `--standby` or `--global`, HelloAGENTS first reuses the tracked/dete
 
 Use these when you do not want to depend on the `helloagents` binary being available during package updates. In `HELLOAGENTS=target[:mode]`, target can be `all`, `claude`, `gemini`, or `codex`; mode can be `standby` or `global`. For install, an omitted mode is treated as `standby`. For update, cleanup, uninstall, and branch switching, an omitted mode is forwarded unchanged so HelloAGENTS can reuse the tracked or detected mode for that CLI first. If you do not provide `HELLOAGENTS`, the one-shot install scripts now behave like plain package install: they install or update the package only and do not auto-deploy any host CLI. For a custom tarball or package spec, set `HELLOAGENTS_PACKAGE` instead of `HELLOAGENTS_BRANCH`. For a guaranteed refresh of an already installed package, prefer `npm explore -g helloagents -- npm run sync-hosts -- ...` after the package command.
 
-Host configs use the stable `helloagents-js` entrypoint and runtime root `~/.helloagents/helloagents`, so Node global package paths can change without breaking managed hooks or Codex `notify`. Codex hooks use standalone `~/.codex/hooks.json` instead of adding large hook blocks to `config.toml`, and Codex global plugin roots plus plugin cache now link back to that same stable runtime root.
+Host configs use the stable `helloagents-js` entrypoint and runtime root `~/.helloagents/helloagents`, so Node global package paths can change without breaking managed hooks or Codex `notify`. Codex hooks use standalone `~/.codex/hooks.json` instead of adding large hook blocks to `config.toml`, and Codex global plugin roots plus plugin cache now link back to that same stable runtime root. Claude Code global installs now use a dedicated local marketplace projection under `~/.helloagents/host-projections/claude-marketplace`, and Gemini global extension packaging uses `~/.helloagents/host-projections/gemini`, so host-specific packaging stays isolated from the shared runtime root.
 
 #### npm commands
 
@@ -445,16 +447,16 @@ npm uninstall -g helloagents
 
 | CLI | Install method | Files involved |
 |-----|----------------|----------------|
-| Claude Code | native plugin install | managed by Claude Code plugin system |
-| Gemini CLI | native extension install | managed by Gemini extension system |
+| Claude Code | native plugin install | `~/.helloagents/host-projections/claude-marketplace`, Claude Code plugin metadata/cache managed by the host |
+| Gemini CLI | native extension install | `~/.helloagents/host-projections/gemini`, `~/.gemini/extensions/helloagents` |
 | Codex CLI | native local-plugin chain | `~/.agents/plugins/marketplace.json`, `~/plugins/helloagents/ -> ~/.helloagents/helloagents`, `~/.codex/plugins/cache/local-plugins/helloagents/local/ -> ~/.helloagents/helloagents`, `~/.codex/config.toml`, `~/.codex/hooks.json`, `~/.codex/helloagents -> ~/.helloagents/helloagents` |
 
-In global mode, HelloAGENTS now attempts the host-native install commands automatically. For Claude Code, the marketplace should be added from the Git URL so the plugin source stays on HTTPS and avoids an SSH-only clone during installation. If a host command is unavailable, run the same commands manually:
+In global mode, HelloAGENTS now attempts the host-native install commands automatically. Claude Code uses the local marketplace projection, Gemini uses the local extension projection, and Codex keeps linking back to the same stable runtime root, so install, update, branch switching, mode switching, cleanup, and uninstall all refresh against one consistent runtime copy. If a host command is unavailable, run the same commands manually:
 
 ```text
-/plugin marketplace add https://github.com/hellowind777/helloagents.git
+/plugin marketplace add "~/.helloagents/host-projections/claude-marketplace"
 /plugin install helloagents@helloagents
-helloagents install gemini --global
+gemini extensions link "~/.helloagents/host-projections/gemini"
 ```
 
 For Claude Code, the CLI also tries the equivalent `claude plugin marketplace add ...` and `claude plugin install ...` commands. The marketplace is named `helloagents`, and the plugin is also named `helloagents`, so the install target is `helloagents@helloagents`. Restart the host CLI after a global install.
@@ -652,13 +654,14 @@ Codex is rules-file driven by default.
 
 - standby writes `~/.codex/AGENTS.md`
 - standby writes a portable managed `model_instructions_file = "~/.codex/AGENTS.md"`
-- standby writes a managed `notify = ["helloagents-js", "codex-notify"]` command for closeout notification
+- standby writes a managed and portable `notify = ["helloagents-js", "codex-notify"]` command for closeout notification, so reinstalling, updating, or moving to another machine does not require rewriting an absolute path
 - standby writes silent Codex hooks to `~/.codex/hooks.json`
 - Codex `SessionStart` stays silent and reads the current `~/.helloagents/helloagents.json` at runtime instead of baking a config snapshot into `config.toml`, so first-turn and post-compaction settings stay current
 - install and update also sync HelloAGENTS-managed Codex hook trust state in `~/.codex/config.toml`, so Codex 0.129.0+ does not re-prompt for the managed hooks
 - that hook trust state is machine-local generated metadata derived from the current absolute `~/.codex/hooks.json` path; unlike `model_instructions_file = "~/.codex/AGENTS.md"`, it is not portable config and should be regenerated on each machine
 - standby creates `~/.codex/helloagents -> ~/.helloagents/helloagents`
 - global mode installs the native local-plugin chain, but keeps `~/.helloagents/helloagents` as the single managed runtime source by linking plugin roots, plugin cache, and `~/.codex/helloagents` back to it
+- `doctor`, `cleanup`, and `uninstall` also recognize wrapped notify chains such as `--previous-notify ["helloagents-js", "codex-notify"]`, so Codex App / Computer Use wrappers do not cause false drift reports or break notify restoration
 - for Codex app/plugin discovery, `global` is the native path; `standby` remains the lighter default for explicit project work
 - cleanup removes only the HelloAGENTS-managed hook trust entries, while keeping user-owned hook state untouched
 - Codex hooks only synchronize runtime state and enforce Stop gates; they do not inject HelloAGENTS rules or route text through hook output
@@ -678,10 +681,11 @@ npm test
 The current suite covers:
 
 - install, update, cleanup, uninstall, branch switching, and mode switching
+- Windows `.cmd` / `.bat` lifecycle dispatch without Node `DEP0190` warnings
 - one-shot shell and PowerShell lifecycle dispatch, plus wrapper env cleanup and mode-routing rules for install, update, cleanup, uninstall, and branch switching
 - Claude, Gemini, and Codex host integration behavior, including global-to-standby cleanup and failed native cleanup tracking
 - Codex managed `model_instructions_file`, `notify`, `hooks.json`, hook trust state, local plugin, marketplace, and cache behavior
-- Codex cleanup and canonical managed notify restoration rules
+- Codex cleanup and canonical managed notify restoration rules, including wrapped `--previous-notify` chains
 - Codex `/goal` feature toggles, long-running route context, and goal-aware command contracts
 - `helloagents doctor`
 - project storage and `repo-shared` behavior

package/README_CN.md

@@ -8,7 +8,7 @@
 
 **面向 AI 编码 CLI 的工作流层：技能、知识库、交付检查、更安全的配置写入，以及可恢复的执行流程。**
 
-[![Version](https://img.shields.io/badge/version-3.0.39-orange.svg)](./package.json)
+[![Version](https://img.shields.io/badge/version-3.1.1-orange.svg)](./package.json)
 [![npm](https://img.shields.io/npm/v/helloagents.svg)](https://www.npmjs.com/package/helloagents)
 [![Node](https://img.shields.io/badge/node-%3E%3D18-339933.svg)](./package.json)
 [![Skills](https://img.shields.io/badge/skills-14-6366f1.svg)](./skills)
@@ -225,8 +225,10 @@ CLI 显式管理宿主文件：
 - `update` 刷新指定目标或全部目标
 - `cleanup` 删除受管注入和链接
 - `uninstall` 在移除包前执行对应清理
-- `doctor` 检查规则文件、链接、hooks、配置项、插件根目录、缓存副本和版本漂移；对 Codex 还会在可用时附带原生 `codex doctor` 结果
+- `doctor` 检查规则文件、链接、hooks、配置项、插件根目录、缓存副本、版本漂移，以及 Claude / Gemini 是否真的装上了全局插件或扩展；对 Codex 还会在可用时附带原生 `codex doctor` 结果
+- Codex 受管 `notify = ["helloagents-js", "codex-notify"]` 会继续保持可移植；`doctor`、`cleanup` 和 `uninstall` 也能识别 Codex App / Computer Use 使用的 `--previous-notify` 包装链
 - 单 CLI 模式记录只会在宿主安装成功后写入；如果原生全局清理失败，也会继续保留 `global` 记录，而不是悄悄叠加 standby
+- Windows 下的 `.cmd` / `.bat` 生命周期调用现在统一走显式命令包装，不再出现 Node `DEP0190` shell 弃用警告
 
 ## 快速开始
 
@@ -313,7 +315,7 @@ helloagents codex goals enable
 
 当你不想依赖更新过程中的 `helloagents` 可执行文件时，用 npm 或一键脚本。`HELLOAGENTS=目标[:模式]` 中，目标支持 `all`、`claude`、`gemini`、`codex`；模式支持 `standby`、`global`。用于安装时，省略模式按 `standby` 处理；用于更新、清理、卸载和切换分支时，省略模式会原样下传，让 HelloAGENTS 先复用该 CLI 已记录或检测到的模式。如果未提供 `HELLOAGENTS`，一键安装脚本现在会保持“只装包/只升级包”的默认语义，不会自动部署任何宿主 CLI。若要安装自定义 tarball 或包规格，用 `HELLOAGENTS_PACKAGE`，不要写 `HELLOAGENTS_BRANCH`。对于已经装好的包，如需确保宿主一定刷新，优先在包命令后显式执行一次 `npm explore -g helloagents -- npm run sync-hosts -- ...`。
 
-宿主配置使用稳定的 `helloagents-js` 入口和运行根目录 `~/.helloagents/helloagents`，Node 全局包路径变化不会破坏受管 hooks 或 Codex `notify`。Codex hooks 使用独立 `~/.codex/hooks.json`，不把大段配置写入 `config.toml`；Codex 全局插件根目录和插件缓存也会回链到这个稳定运行根目录。
+宿主配置使用稳定的 `helloagents-js` 入口和运行根目录 `~/.helloagents/helloagents`，Node 全局包路径变化不会破坏受管 hooks 或 Codex `notify`。Codex hooks 使用独立 `~/.codex/hooks.json`，不把大段配置写入 `config.toml`；Codex 全局插件根目录和插件缓存也会回链到这个稳定运行根目录。Claude Code 的 global 安装现在使用独立本地 marketplace 投影 `~/.helloagents/host-projections/claude-marketplace`，Gemini 的 global 扩展使用 `~/.helloagents/host-projections/gemini`，宿主专用打包链路不再污染共享运行根。
 
 #### npm 命令
 
@@ -445,16 +447,16 @@ npm uninstall -g helloagents
 
 | CLI | 安装方式 | 涉及文件 |
 |-----|----------|----------|
-| Claude Code | 原生插件安装 | 由 Claude Code 插件系统管理 |
-| Gemini CLI | 原生扩展安装 | 由 Gemini 扩展系统管理 |
+| Claude Code | 原生插件安装 | `~/.helloagents/host-projections/claude-marketplace`，以及由 Claude Code 宿主管理的插件元数据 / 缓存 |
+| Gemini CLI | 原生扩展安装 | `~/.helloagents/host-projections/gemini`、`~/.gemini/extensions/helloagents` |
 | Codex CLI | 原生本地插件流程 | `~/.agents/plugins/marketplace.json`、`~/plugins/helloagents/ -> ~/.helloagents/helloagents`、`~/.codex/plugins/cache/local-plugins/helloagents/local/ -> ~/.helloagents/helloagents`、`~/.codex/config.toml`、`~/.codex/hooks.json`、`~/.codex/helloagents -> ~/.helloagents/helloagents` |
 
-全局模式下，HelloAGENTS 会自动尝试宿主原生命令。对 Claude Code，marketplace 应使用 Git URL 添加，这样插件安装阶段会继续走 HTTPS，不会落回 SSH-only clone。若宿主命令不可用，再手动执行：
+全局模式下，HelloAGENTS 会自动尝试宿主原生命令。Claude Code 走本地 marketplace 投影，Gemini 走本地 extension 投影，Codex 继续回链同一个稳定运行根，因此安装、更新、切分支、切模式、清理和卸载都会围绕同一份运行时副本刷新。若宿主命令不可用，再手动执行：
 
 ```text
-/plugin marketplace add https://github.com/hellowind777/helloagents.git
+/plugin marketplace add "~/.helloagents/host-projections/claude-marketplace"
 /plugin install helloagents@helloagents
-helloagents install gemini --global
+gemini extensions link "~/.helloagents/host-projections/gemini"
 ```
 
 Claude Code 会自动尝试等价的 `claude plugin marketplace add ...` 和 `claude plugin install ...` 命令。marketplace 名称和插件名称都是 `helloagents`，所以安装目标是 `helloagents@helloagents`。全局安装后需要重启宿主 CLI。
@@ -656,13 +658,14 @@ Codex 默认走规则文件驱动。
 
 - 标准模式写入 `~/.codex/AGENTS.md`
 - 标准模式写入可移植的受管 `model_instructions_file = "~/.codex/AGENTS.md"`
-- 标准模式写入受管 `notify = ["helloagents-js", "codex-notify"]` 命令用于收尾通知
+- 标准模式写入受管且可移植的 `notify = ["helloagents-js", "codex-notify"]` 命令用于收尾通知，因此重装、更新或换电脑时都不需要改写绝对路径
 - 标准模式把静默 Codex hooks 写入 `~/.codex/hooks.json`
 - Codex 的 `SessionStart` 保持静默，并在运行时读取当前 `~/.helloagents/helloagents.json`，不会把配置快照固化进 `config.toml`，因此首次对话和上下文压缩后的设置都能保持最新
 - 安装和更新还会把 HelloAGENTS 受管的 Codex hook trust 状态同步到 `~/.codex/config.toml`，因此 Codex 0.129.0+ 不会再对这些受管 hooks 反复提示确认
 - 这些 hook trust 状态是基于当前机器 `~/.codex/hooks.json` 真实绝对路径生成的本机状态；它不同于 `model_instructions_file = "~/.codex/AGENTS.md"` 这类可移植配置，应在每台机器上重新生成
 - 标准模式创建 `~/.codex/helloagents -> ~/.helloagents/helloagents`
 - 全局模式安装原生本地插件流程，但仍把 `~/.helloagents/helloagents` 作为唯一受管运行时源；插件根目录、插件缓存和 `~/.codex/helloagents` 都会回链到它
+- `doctor`、`cleanup` 和 `uninstall` 也能识别 `--previous-notify ["helloagents-js", "codex-notify"]` 这类包装后的 notify 链，因此 Codex App / Computer Use 不会再触发误报或破坏 notify 恢复
 - 如果你主要看重 Codex app / 插件发现链路，优先使用 `global`；如果你主要看重更轻量、更显式的项目工作流，保留 `standby`
 - 清理时只删除 HelloAGENTS 自己写入的 hook trust 条目，不影响用户已有的 hook 状态
 - Codex hooks 只做静默运行态同步和 Stop 门禁，不通过 hook 注入 HelloAGENTS 规则或路由说明
@@ -682,10 +685,11 @@ npm test
 当前测试覆盖：
 
 - 安装、更新、清理、卸载、分支切换和模式切换
+- Windows `.cmd` / `.bat` 生命周期分发链路，且不再出现 Node `DEP0190` 警告
 - shell 与 PowerShell 一键脚本分发链路，以及包装脚本在安装、更新、清理、卸载和分支切换中的环境清理与模式传递规则
 - Claude、Gemini、Codex 的宿主集成行为，包括全局切回标准模式的清理和原生清理失败时的模式保留
 - Codex 受管 `model_instructions_file`、`notify`、`hooks.json`、hook trust 状态、本地插件、marketplace 和缓存行为
-- Codex 清理链路，以及受管 notify 恢复规则
+- Codex 清理链路，以及包括 wrapped `--previous-notify` 在内的受管 notify 恢复规则
 - Codex `/goal` 功能开关、长程路由上下文和 goal 感知命令契约
 - `helloagents doctor`
 - 项目存储和 `repo-shared`

package/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "helloagents",
-  "version": "3.0.39",
+  "version": "3.1.1",
   "description": "Quality-driven orchestration kernel for AI CLIs",
   "contextFileName": "bootstrap.md",
   "author": "HelloWind",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "helloagents",
-  "version": "3.0.39",
+  "version": "3.1.1",
   "type": "module",
   "description": "HelloAGENTS — The orchestration kernel that makes any AI CLI smarter. Adds intelligent routing, unified QA gates, safety guards, and notifications.",
   "author": "HelloWind",

package/scripts/cli-branch.mjs

@@ -1,15 +1,12 @@
-import { spawnSync } from 'node:child_process'
-
 import { normalizeHost } from './cli-lifecycle.mjs'
+import { spawnCommandSync } from './cli-process.mjs'
 
 const DEFAULT_REPO_ARCHIVE_BASE = 'https://github.com/hellowind777/helloagents/archive/refs/heads'
 
 function runCommand(command, args) {
-  const needsShell = process.platform === 'win32' && /\.cmd$/i.test(command)
-  const result = spawnSync(command, args, {
+  const result = spawnCommandSync(command, args, {
     encoding: 'utf-8',
     errors: 'replace',
-    shell: needsShell,
     stdio: 'inherit',
     windowsHide: true,
   })

package/scripts/cli-codex-config.mjs

@@ -24,6 +24,155 @@ function normalizePath(value = '') {
   return String(value || '').replace(/\\/g, '/')
 }
 
+function isManagedCodexNotifyParts(parts) {
+  return Array.isArray(parts)
+    && parts.length === 2
+    && parts[0] === CODEX_MANAGED_NOTIFY_COMMAND
+    && parts[1] === 'codex-notify'
+}
+
+function extractTomlArrayLiteral(text = '') {
+  const source = String(text || '')
+  const equalsIndex = source.indexOf('=')
+  let quoted = false
+  let escaped = false
+  let commented = false
+  let depth = 0
+  let start = -1
+
+  for (let index = equalsIndex >= 0 ? equalsIndex + 1 : 0; index < source.length; index += 1) {
+    const char = source[index]
+
+    if (commented) {
+      if (char === '\n') commented = false
+      continue
+    }
+    if (escaped) {
+      escaped = false
+      continue
+    }
+    if (char === '\\' && quoted) {
+      escaped = true
+      continue
+    }
+    if (char === '"') {
+      quoted = !quoted
+      continue
+    }
+    if (quoted) continue
+    if (char === '#') {
+      commented = true
+      continue
+    }
+    if (char === '[') {
+      if (depth === 0) start = index
+      depth += 1
+      continue
+    }
+    if (char === ']' && depth > 0) {
+      depth -= 1
+      if (depth === 0 && start >= 0) return source.slice(start, index + 1)
+    }
+  }
+
+  return ''
+}
+
+function parseTomlStringArrayLiteral(literal = '') {
+  const source = String(literal || '').trim()
+  if (!source.startsWith('[') || !source.endsWith(']')) return null
+
+  const items = []
+  let quoted = false
+  let escaped = false
+  let tokenStart = -1
+
+  for (let index = 1; index < source.length; index += 1) {
+    const char = source[index]
+
+    if (quoted) {
+      if (escaped) {
+        escaped = false
+        continue
+      }
+      if (char === '\\') {
+        escaped = true
+        continue
+      }
+      if (char === '"') {
+        try {
+          items.push(JSON.parse(source.slice(tokenStart, index + 1)))
+        } catch {
+          return null
+        }
+        quoted = false
+        tokenStart = -1
+      }
+      continue
+    }
+
+    if (char === '#') {
+      while (index < source.length && source[index] !== '\n') index += 1
+      continue
+    }
+    if (/\s|,/.test(char)) continue
+    if (char === ']') return items
+    if (char !== '"') return null
+
+    quoted = true
+    tokenStart = index
+  }
+
+  return null
+}
+
+function analyzeNotifyCommandParts(parts = []) {
+  if (isManagedCodexNotifyParts(parts)) {
+    return {
+      managed: true,
+      shape: 'direct',
+      containsCodexNotify: true,
+      entrypoint: [...parts],
+      wrapper: '',
+      rawCommand: [...parts],
+    }
+  }
+
+  let containsCodexNotify = parts.includes('codex-notify')
+  for (let index = 0; index < parts.length - 1; index += 1) {
+    if (parts[index] !== '--previous-notify') continue
+
+    try {
+      const nested = JSON.parse(parts[index + 1])
+      if (!Array.isArray(nested) || !nested.every((entry) => typeof entry === 'string')) continue
+
+      const nestedAnalysis = analyzeNotifyCommandParts(nested)
+      containsCodexNotify = containsCodexNotify || nestedAnalysis.containsCodexNotify
+      if (!nestedAnalysis.managed) continue
+
+      return {
+        managed: true,
+        shape: 'chained',
+        containsCodexNotify: true,
+        entrypoint: [...nestedAnalysis.entrypoint],
+        wrapper: parts[0] || '',
+        rawCommand: [...parts],
+      }
+    } catch {
+      continue
+    }
+  }
+
+  return {
+    managed: false,
+    shape: parts.length ? 'external' : 'invalid',
+    containsCodexNotify,
+    entrypoint: [],
+    wrapper: '',
+    rawCommand: [...parts],
+  }
+}
+
 function splitTomlLines(text = '') {
   return String(text || '').replace(/\r\n/g, '\n').split('\n')
 }
@@ -158,6 +307,43 @@ export function isManagedCodexNotify(line = '') {
     && value.includes(CODEX_MANAGED_NOTIFY_VALUE)
 }
 
+export function analyzeCodexNotifyBlock(block = '') {
+  const source = String(block || '').trim()
+  if (!source) {
+    return {
+      exists: false,
+      managed: false,
+      containsCodexNotify: false,
+      shape: 'missing',
+      entrypoint: [],
+      wrapper: '',
+      rawCommand: [],
+      rawBlock: '',
+    }
+  }
+
+  const literal = extractTomlArrayLiteral(source)
+  const parts = literal ? parseTomlStringArrayLiteral(literal) : null
+  if (!parts) {
+    return {
+      exists: true,
+      managed: false,
+      containsCodexNotify: source.includes('codex-notify'),
+      shape: 'invalid',
+      entrypoint: [],
+      wrapper: '',
+      rawCommand: [],
+      rawBlock: source,
+    }
+  }
+
+  return {
+    exists: true,
+    ...analyzeNotifyCommandParts(parts),
+    rawBlock: source,
+  }
+}
+
 export function isManagedCodexTuiNotifications(line = '') {
   return String(line || '').includes(CODEX_MANAGED_TUI_NOTIFICATIONS_VALUE)
     && String(line || '').includes(CODEX_MANAGED_TOML_COMMENT)

package/scripts/cli-codex.mjs

@@ -8,6 +8,7 @@ import {
 } from './cli-utils.mjs';
 import { ensureTimestampedBackup, readCodexBackup, removeCodexBackup } from './cli-codex-backup.mjs';
 import {
+  analyzeCodexNotifyBlock,
   CODEX_MANAGED_TOML_COMMENT,
   CODEX_MANAGED_MODEL_INSTRUCTIONS_PATH,
   CODEX_PLUGIN_CONFIG_HEADER,
@@ -30,8 +31,10 @@ import {
   syncManagedCodexHookTrust,
 } from './cli-codex-hooks-state.mjs';
 import {
+  hasTopLevelTomlBlock,
   readTopLevelTomlLine,
   readTopLevelTomlBlock,
+  removeTopLevelTomlBlock,
   removeTopLevelTomlLines,
 } from './cli-toml.mjs';
 import { buildRuntimeCarrier, readCarrierSettings } from './cli-runtime-carrier.mjs';
@@ -153,9 +156,10 @@ function cleanupCodexManagedConfig(configPath, { removePluginConfig = false } =
   const currentModelInstructions = readTopLevelTomlLine(toml, 'model_instructions_file');
   const currentNotify = readTopLevelTomlBlock(toml, 'notify');
   const currentCodexGoalsFeature = readCodexGoalsFeatureLine(toml);
+  const currentNotifyAnalysis = analyzeCodexNotifyBlock(currentNotify);
 
   const shouldRestoreModelInstructions = isManagedCodexModelInstruction(currentModelInstructions);
-  const shouldRestoreNotify = isManagedCodexNotify(currentNotify);
+  const shouldRestoreNotify = currentNotifyAnalysis.managed || isManagedCodexNotify(currentNotify);
   const shouldRestoreCodexGoalsFeature = isManagedCodexGoalsFeature(currentCodexGoalsFeature);
 
   if (removePluginConfig) {
@@ -170,8 +174,10 @@ function cleanupCodexManagedConfig(configPath, { removePluginConfig = false } =
       line.startsWith('model_instructions_file =') && isManagedCodexModelInstruction(line)).text;
   }
   if (shouldRestoreNotify) {
-    toml = removeTopLevelTomlLines(toml, (line) =>
-      line.startsWith('notify =') && isManagedCodexNotify(line)).text;
+    toml = hasTopLevelTomlBlock(toml, 'notify')
+      ? removeTopLevelTomlBlock(toml, 'notify')
+      : removeTopLevelTomlLines(toml, (line) =>
+        line.startsWith('notify =')).text;
   }
 
   const backupModelInstructions = readTopLevelTomlLine(backupToml, 'model_instructions_file');
@@ -182,7 +188,7 @@ function cleanupCodexManagedConfig(configPath, { removePluginConfig = false } =
     modelInstructionsLine: shouldRestoreModelInstructions && !isManagedCodexBackupInstruction(backupModelInstructions)
       ? backupModelInstructions
       : '',
-    notifyLine: shouldRestoreNotify && !isManagedCodexNotify(backupNotify)
+    notifyLine: shouldRestoreNotify && !analyzeCodexNotifyBlock(backupNotify).managed
       ? backupNotify
       : '',
   });

package/scripts/cli-doctor-codex.mjs

@@ -1,12 +1,11 @@
-import { spawnSync } from 'node:child_process'
 import { existsSync, realpathSync } from 'node:fs'
 import { platform } from 'node:os'
 import { join } from 'node:path'
 
 import { CODEX_MARKETPLACE_NAME, CODEX_PLUGIN_CONFIG_HEADER, CODEX_PLUGIN_NAME } from './cli-codex.mjs'
 import {
+  analyzeCodexNotifyBlock,
   CODEX_MANAGED_MODEL_INSTRUCTIONS_PATH,
-  CODEX_MANAGED_NOTIFY_VALUE,
   readCodexGoalsFeatureLine,
   readCodexHooksFeatureLine,
 } from './cli-codex-config.mjs'
@@ -16,7 +15,8 @@ import {
 } from './cli-codex-hooks-state.mjs'
 import { getStableRuntimeRoot } from './cli-runtime-root.mjs'
 import { buildRuntimeCarrier } from './cli-runtime-carrier.mjs'
-import { readTopLevelTomlLine } from './cli-toml.mjs'
+import { readTopLevelTomlBlock, readTopLevelTomlLine } from './cli-toml.mjs'
+import { spawnCommandSync } from './cli-process.mjs'
 import { loadHooksWithCliEntry, safeJson, safeRead } from './cli-utils.mjs'
 
 function safeRealTarget(linkPath) {
@@ -149,7 +149,7 @@ function summarizeNativeCodexDoctorOutput(payload = {}) {
 function inspectNativeCodexDoctor(runtime) {
   const command = platform() === 'win32' ? 'codex.cmd' : 'codex'
   try {
-    const result = spawnSync(command, ['doctor', '--json'], {
+    const result = spawnCommandSync(command, ['doctor', '--json'], {
       cwd: process.cwd(),
       env: {
         ...process.env,
@@ -159,7 +159,6 @@ function inspectNativeCodexDoctor(runtime) {
       },
       encoding: 'utf-8',
       timeout: 20_000,
-      shell: platform() === 'win32',
       windowsHide: true,
     })
 
@@ -259,6 +258,8 @@ function appendCodexGlobalIssues(runtime, issues, checks, pluginVersion, cacheVe
   if (!checks.pluginCache) issues.push(buildDoctorIssue(runtime, 'global-plugin-cache-missing', 'global 插件缓存目录缺失', 'Global plugin cache directory is missing'))
   if (checks.pluginRoot && !checks.pluginRootLink) issues.push(buildDoctorIssue(runtime, 'global-plugin-root-link-drift', 'global 插件根目录未链接到稳定运行根目录', 'Global plugin root does not link to the stable runtime root'))
   if (checks.pluginCache && !checks.pluginCacheLink) issues.push(buildDoctorIssue(runtime, 'global-plugin-cache-link-drift', 'global 插件缓存未链接到稳定运行根目录', 'Global plugin cache does not link to the stable runtime root'))
+  if (checks.pluginGenericHooks) issues.push(buildDoctorIssue(runtime, 'global-plugin-generic-hooks-present', 'global 插件根目录中意外存在通用 `hooks/hooks.json`，可能污染 Codex 本地插件 hook 加载', 'Global plugin root unexpectedly contains a generic `hooks/hooks.json`, which can pollute Codex local-plugin hook loading'))
+  if (checks.pluginCacheGenericHooks) issues.push(buildDoctorIssue(runtime, 'global-plugin-cache-generic-hooks-present', 'global 插件缓存中意外存在通用 `hooks/hooks.json`，可能污染 Codex 本地插件 hook 加载', 'Global plugin cache unexpectedly contains a generic `hooks/hooks.json`, which can pollute Codex local-plugin hook loading'))
   if (checks.pluginRoot && !checks.pluginCarrierMatch) issues.push(buildDoctorIssue(runtime, 'global-plugin-carrier-drift', 'global 插件根目录中的 AGENTS.md 与当前全局模式规则不一致', 'Global plugin AGENTS.md differs from the current global rules'))
   if (checks.pluginCache && !checks.pluginCacheCarrierMatch) issues.push(buildDoctorIssue(runtime, 'global-plugin-cache-carrier-drift', 'global 插件缓存中的 AGENTS.md 与当前全局模式规则不一致', 'Global plugin cache AGENTS.md differs from the current global rules'))
   if (!checks.marketplaceEntry) issues.push(buildDoctorIssue(runtime, 'global-marketplace-missing', 'global marketplace 条目缺失', 'Global marketplace entry is missing'))
@@ -285,12 +286,16 @@ function buildCodexChecks(runtime, settings, trackedMode, detectedMode) {
   const homeLinkTarget = safeRealTarget(join(codexDir, 'helloagents'))
   const pluginRootTarget = safeRealTarget(pluginRoot)
   const pluginCacheTarget = safeRealTarget(pluginCacheRoot)
+  const pluginGenericHooks = !!safeRead(join(pluginRoot, 'hooks', 'hooks.json'))
+  const pluginCacheGenericHooks = !!safeRead(join(pluginCacheRoot, 'hooks', 'hooks.json'))
   const expectedHomeCarrier = (detectedMode === 'global' || (detectedMode === 'none' && trackedMode === 'global'))
     ? 'bootstrap.md'
     : 'bootstrap-lite.md'
   const codexHooks = safeJson(join(codexDir, 'hooks.json')) || {}
   const marketplace = safeJson(join(runtime.home, '.agents', 'plugins', 'marketplace.json')) || {}
   const modelInstructionsLine = readTopLevelTomlLine(codexConfig, 'model_instructions_file')
+  const notifyBlock = readTopLevelTomlBlock(codexConfig, 'notify')
+  const notifyAnalysis = analyzeCodexNotifyBlock(notifyBlock)
   const expectedHooks = readExpectedHooks(runtime, 'hooks-codex.json', '${PLUGIN_ROOT}')
   const expectedHookTrust = buildManagedCodexHookTrustEntries(join(codexDir, 'hooks.json'), codexHooks)
   const managedHookTrust = new Map(
@@ -314,8 +319,9 @@ function buildCodexChecks(runtime, settings, trackedMode, detectedMode) {
       globalHomeLink: homeLinkTarget === runtimeRoot,
       modelInstructionsFile: !!modelInstructionsLine,
       modelInstructionsPathMatch: !!modelInstructionsLine && normalizePath(modelInstructionsLine).includes(`"${CODEX_MANAGED_MODEL_INSTRUCTIONS_PATH}"`),
-      codexNotify: codexConfig.includes('codex-notify'),
-      notifyPathMatch: codexConfig.includes(CODEX_MANAGED_NOTIFY_VALUE),
+      codexNotify: notifyAnalysis.containsCodexNotify,
+      notifyPathMatch: notifyAnalysis.managed,
+      notifyShape: notifyAnalysis.shape,
       codexHooksFeature: !/^\s*hooks\s*=\s*false\b/.test(hooksFeatureLine),
       codexGoalsFeature: /^\s*goals\s*=\s*true\b/.test(goalsFeatureLine),
       standaloneHooks: JSON.stringify(codexHooks.hooks || {}).includes('helloagents'),
@@ -326,11 +332,13 @@ function buildCodexChecks(runtime, settings, trackedMode, detectedMode) {
       pluginCache: existsSync(pluginCacheRoot),
       pluginRootLink: pluginRootTarget === runtimeRoot,
       pluginCacheLink: pluginCacheTarget === runtimeRoot,
+      pluginGenericHooks,
+      pluginCacheGenericHooks,
       pluginCarrierMatch: normalizeText(safeRead(join(pluginRoot, 'AGENTS.md')) || '') === readExpectedCarrierContent(runtime, 'bootstrap.md', settings, { profile: 'full' }),
       pluginCacheCarrierMatch: normalizeText(safeRead(join(pluginCacheRoot, 'AGENTS.md')) || '') === readExpectedCarrierContent(runtime, 'bootstrap.md', settings, { profile: 'full' }),
       marketplaceEntry: Array.isArray(marketplace.plugins) && marketplace.plugins.some((plugin) => plugin?.name === CODEX_PLUGIN_NAME),
       pluginEnabled: codexConfig.includes(CODEX_PLUGIN_CONFIG_HEADER) && codexConfig.includes('enabled = true'),
-      globalNotifyPathMatch: codexConfig.includes(CODEX_MANAGED_NOTIFY_VALUE),
+      globalNotifyPathMatch: notifyAnalysis.managed,
       pluginVersionMatch: false,
       pluginCacheVersionMatch: false,
     },
@@ -364,6 +372,7 @@ export function inspectCodexDoctor(runtime, settings) {
   if (!checks.pluginVersionMatch && !pluginVersion && detectedMode === 'global') notes.push(runtime.msg('未读到 global 插件根目录版本信息', 'Global plugin root version was not readable'))
   if (!checks.pluginCacheVersionMatch && !cacheVersion && detectedMode === 'global') notes.push(runtime.msg('未读到 global 插件缓存版本信息', 'Global plugin cache version was not readable'))
   if (detectedMode !== 'none' && !checks.codexGoalsFeature) notes.push(runtime.msg('Codex /goal 未启用；如需长程执行，可运行 `helloagents codex goals enable`。', 'Codex /goal is not enabled; run `helloagents codex goals enable` if you need long-running goals.'))
+  if (checks.notifyShape === 'chained') notes.push(runtime.msg('HelloAGENTS notify 当前通过 Codex Computer Use / wrapper 链式转发，仍视为有效。', 'HelloAGENTS notify is currently chained through Codex Computer Use / a wrapper and is still treated as valid.'))
   if (!nativeDoctor.available) notes.push(runtime.msg('未检测到原生 `codex doctor`；当前仅检查 HelloAGENTS 受管覆盖层。', 'Native `codex doctor` was not available; only the HelloAGENTS managed overlay was checked.'))
 
   const status = summarizeDoctorStatus(issues, { trackedMode, detectedMode })

package/scripts/cli-doctor.mjs

@@ -1,12 +1,16 @@
-import { realpathSync } from 'node:fs'
+import { existsSync, realpathSync } from 'node:fs'
 import { join } from 'node:path'
 
 import { DEFAULTS } from './cli-config.mjs'
 import { inspectCodexDoctor as inspectCodexDoctorImpl } from './cli-doctor-codex.mjs'
 import { printDoctorText } from './cli-doctor-render.mjs'
 import { buildRuntimeCarrier } from './cli-runtime-carrier.mjs'
+import { getClaudeMarketplaceRoot, getGeminiExtensionRoot } from './cli-runtime-root.mjs'
 import { loadHooksWithCliEntry, safeJson, safeRead } from './cli-utils.mjs'
 
+const CLAUDE_PLUGIN = 'helloagents@helloagents'
+const GEMINI_EXTENSION = 'helloagents'
+
 const runtime = {
   home: '',
   pkgRoot: '',
@@ -93,6 +97,16 @@ function normalizeDoctorMode(mode = '') {
   return mode || 'none'
 }
 
+function hasEnabledPlugin(enabledPlugins, pluginName) {
+  if (Array.isArray(enabledPlugins)) {
+    return enabledPlugins.includes(pluginName)
+  }
+  if (enabledPlugins && typeof enabledPlugins === 'object') {
+    return Boolean(enabledPlugins[pluginName])
+  }
+  return false
+}
+
 function summarizeDoctorStatus(issues, { host, trackedMode, detectedMode } = {}) {
   if (issues.length > 0) return 'drift'
   if (detectedMode !== 'none') return 'ok'
@@ -106,8 +120,8 @@ function suggestDoctorFix(host, status, trackedMode) {
     return `helloagents update ${host}${trackedMode && trackedMode !== 'none' ? ` --${trackedMode}` : ''}`
   }
   if (status === 'manual-plugin') {
-    if (host === 'claude') return '/plugin marketplace add https://github.com/hellowind777/helloagents.git; /plugin install helloagents@helloagents'
-    if (host === 'gemini') return 'helloagents install gemini --global'
+    if (host === 'claude') return `/plugin marketplace add "${getClaudeMarketplaceRoot(runtime.home)}"; /plugin install helloagents@helloagents`
+    if (host === 'gemini') return `gemini extensions link "${getGeminiExtensionRoot(runtime.home)}"`
   }
   if (status === 'not-installed') {
     return `helloagents install ${host} --standby`
@@ -125,12 +139,18 @@ function inspectClaudeDoctor(settings) {
   const detectedMode = normalizeDoctorMode(runtime.detectHostMode(host))
   const claudeDir = join(runtime.home, '.claude')
   const claudeSettings = safeJson(join(claudeDir, 'settings.json')) || {}
+  const claudePlugins = safeJson(join(claudeDir, 'plugins', 'installed_plugins.json')) || {}
   const expectedHooks = readExpectedHooks('hooks-claude.json', '${CLAUDE_PLUGIN_ROOT}')
+  const marketplaceRoot = getClaudeMarketplaceRoot(runtime.home)
+  const globalPluginInstalled = Boolean(claudePlugins.plugins?.[CLAUDE_PLUGIN]?.length)
+    || hasEnabledPlugin(claudeSettings.enabledPlugins, CLAUDE_PLUGIN)
   const checks = {
     carrierMarker: (safeRead(join(claudeDir, 'CLAUDE.md')) || '').includes('HELLOAGENTS_START'),
     carrierContentMatch: extractManagedCarrierContent(join(claudeDir, 'CLAUDE.md'))
       === readExpectedCarrierContent('bootstrap-lite.md', settings),
     homeLink: safeRealTarget(join(claudeDir, 'helloagents')) === runtime.pkgRoot,
+    globalMarketplaceRoot: existsSync(marketplaceRoot),
+    globalPluginInstalled,
     settingsHooks: JSON.stringify(claudeSettings.hooks || {}).includes('helloagents'),
     settingsHooksMatch: managedHooksMatch(claudeSettings.hooks || {}, expectedHooks),
     settingsPermission: Array.isArray(claudeSettings.permissions?.allow)
@@ -150,14 +170,17 @@ function inspectClaudeDoctor(settings) {
     if (checks.settingsHooks && !checks.settingsHooksMatch) issues.push(buildDoctorIssue('standby-hooks-drift', 'standby settings hooks 与当前 hooks 配置不一致', 'Standby settings hooks differ from the current hook configuration'))
     if (!checks.settingsPermission) issues.push(buildDoctorIssue('standby-permission-missing', 'standby Claude 权限注入缺失', 'Standby Claude permission injection is missing'))
   }
-  if (trackedMode === 'global') {
-    notes.push(runtime.msg(
-      'Claude Code 的 global 模式由宿主插件系统管理；doctor 只检查 standby 残留，不直接探测插件状态。',
-      'Claude Code global mode is managed by the host plugin system; doctor only checks for standby residue and does not inspect plugin state directly.',
-    ))
+  if (detectedMode === 'global') {
+    if (!checks.globalMarketplaceRoot) issues.push(buildDoctorIssue('global-marketplace-root-missing', 'global marketplace 投影缺失', 'Global marketplace projection is missing'))
+    if (!checks.globalPluginInstalled) issues.push(buildDoctorIssue('global-plugin-missing', 'global Claude 插件未安装', 'Global Claude plugin is not installed'))
     if (checks.carrierMarker || checks.homeLink || checks.settingsHooks || checks.settingsPermission) {
-      issues.push(buildDoctorIssue('global-standby-residue', 'global 模式下仍残留 standby 注入/链接', 'Standby injections or links still remain while the host is tracked as global'))
+      issues.push(buildDoctorIssue('global-standby-residue', 'global 模式下仍残留 standby 注入/链接', 'Standby injections or links still remain while the host is detected as global'))
     }
+  } else if (trackedMode === 'global') {
+    notes.push(runtime.msg(
+      'Claude Code 的 global 模式由宿主插件系统管理；doctor 会检查本地 marketplace 投影、已安装插件记录与 standby 残留。',
+      'Claude Code global mode is managed by the host plugin system; doctor checks the local marketplace projection, installed-plugin records, and standby residue.',
+    ))
   }
   if (trackedMode === 'none' && detectedMode !== 'none') {
     issues.push(buildDoctorIssue('untracked-managed-state', '检测到受管状态，但配置中未记录该 CLI 模式', 'Managed state detected but this CLI mode is not tracked in config'))
@@ -177,11 +200,17 @@ function inspectGeminiDoctor(settings) {
   const geminiDir = join(runtime.home, '.gemini')
   const geminiSettings = safeJson(join(geminiDir, 'settings.json')) || {}
   const expectedHooks = readExpectedHooks('hooks-gemini.json', '${extensionPath}')
+  const extensionRoot = getGeminiExtensionRoot(runtime.home)
+  const extensionInstallRoot = join(geminiDir, 'extensions', GEMINI_EXTENSION)
+  const expectedExtensionTarget = safeRealTarget(extensionRoot) || normalizePath(extensionRoot)
   const checks = {
     carrierMarker: (safeRead(join(geminiDir, 'GEMINI.md')) || '').includes('HELLOAGENTS_START'),
     carrierContentMatch: extractManagedCarrierContent(join(geminiDir, 'GEMINI.md'))
       === readExpectedCarrierContent('bootstrap-lite.md', settings),
     homeLink: safeRealTarget(join(geminiDir, 'helloagents')) === runtime.pkgRoot,
+    globalExtensionRoot: existsSync(extensionRoot),
+    globalExtensionLink: safeRealTarget(extensionInstallRoot) === expectedExtensionTarget,
+    globalExtensionInstall: existsSync(extensionInstallRoot),
     settingsHooks: JSON.stringify(geminiSettings.hooks || {}).includes('helloagents'),
     settingsHooksMatch: managedHooksMatch(geminiSettings.hooks || {}, expectedHooks),
   }
@@ -198,14 +227,18 @@ function inspectGeminiDoctor(settings) {
     if (!checks.settingsHooks) issues.push(buildDoctorIssue('standby-hooks-missing', 'standby settings hooks 缺失', 'Standby settings hooks are missing'))
     if (checks.settingsHooks && !checks.settingsHooksMatch) issues.push(buildDoctorIssue('standby-hooks-drift', 'standby settings hooks 与当前 hooks 配置不一致', 'Standby settings hooks differ from the current hook configuration'))
   }
-  if (trackedMode === 'global') {
-    notes.push(runtime.msg(
-      'Gemini CLI 的 global 模式由宿主扩展系统管理；doctor 只检查 standby 残留，不直接探测扩展状态。',
-      'Gemini CLI global mode is managed by the host extension system; doctor only checks for standby residue and does not inspect extension state directly.',
-    ))
+  if (detectedMode === 'global') {
+    if (!checks.globalExtensionRoot) issues.push(buildDoctorIssue('global-extension-root-missing', 'global extension 投影缺失', 'Global extension projection is missing'))
+    if (!checks.globalExtensionInstall) issues.push(buildDoctorIssue('global-extension-missing', 'global Gemini 扩展未安装', 'Global Gemini extension is not installed'))
+    if (!checks.globalExtensionLink) issues.push(buildDoctorIssue('global-extension-link-missing', 'global Gemini 扩展链接未指向投影目录', 'Global Gemini extension link does not point to the projection root'))
     if (checks.carrierMarker || checks.homeLink || checks.settingsHooks) {
-      issues.push(buildDoctorIssue('global-standby-residue', 'global 模式下仍残留 standby 注入/链接', 'Standby injections or links still remain while the host is tracked as global'))
+      issues.push(buildDoctorIssue('global-standby-residue', 'global 模式下仍残留 standby 注入/链接', 'Standby injections or links still remain while the host is detected as global'))
     }
+  } else if (trackedMode === 'global') {
+    notes.push(runtime.msg(
+      'Gemini CLI 的 global 模式由宿主扩展系统管理；doctor 会检查本地扩展投影、已安装链接与 standby 残留。',
+      'Gemini CLI global mode is managed by the host extension system; doctor checks the local extension projection, installed link, and standby residue.',
+    ))
   }
   if (trackedMode === 'none' && detectedMode !== 'none') {
     issues.push(buildDoctorIssue('untracked-managed-state', '检测到受管状态，但配置中未记录该 CLI 模式', 'Managed state detected but this CLI mode is not tracked in config'))

package/scripts/cli-host-detect.mjs

@@ -6,9 +6,12 @@ import {
   CODEX_PLUGIN_KEY,
   CODEX_PLUGIN_NAME,
 } from './cli-codex.mjs'
-import { getStableRuntimeRoot } from './cli-runtime-root.mjs'
+import { getGeminiExtensionRoot, getStableRuntimeRoot } from './cli-runtime-root.mjs'
 import { safeJson, safeRead } from './cli-utils.mjs'
 
+const CLAUDE_PLUGIN = 'helloagents@helloagents'
+const GEMINI_EXTENSION = 'helloagents'
+
 const HOST_ALIASES = new Map([
   ['all', 'all'],
   ['*', 'all'],
@@ -24,8 +27,14 @@ function hasHelloagentsMarker(filePath) {
   return (safeRead(filePath) || '').includes('HELLOAGENTS_START')
 }
 
-function hasHelloagentsSettings(filePath) {
-  return JSON.stringify(safeJson(filePath) || {}).includes('helloagents')
+function hasHelloagentsSettings(filePath, host = '') {
+  const settings = safeJson(filePath) || {}
+  const hooksText = JSON.stringify(settings.hooks || {})
+  if (hooksText.includes('helloagents')) return true
+  if (host === 'claude') {
+    return JSON.stringify(settings.permissions?.allow || []).includes('~/.helloagents/helloagents')
+  }
+  return false
 }
 
 function normalizePath(value = '') {
@@ -40,12 +49,27 @@ function safeRealTarget(linkPath) {
   }
 }
 
+function hasEnabledPlugin(enabledPlugins, pluginName) {
+  if (Array.isArray(enabledPlugins)) {
+    return enabledPlugins.includes(pluginName)
+  }
+  if (enabledPlugins && typeof enabledPlugins === 'object') {
+    return Boolean(enabledPlugins[pluginName])
+  }
+  return false
+}
+
 function detectClaudeMode(home) {
   const claudeDir = join(home, '.claude')
+  const settings = safeJson(join(claudeDir, 'settings.json')) || {}
+  const installedPlugins = safeJson(join(claudeDir, 'plugins', 'installed_plugins.json')) || {}
+  if (hasEnabledPlugin(settings.enabledPlugins, CLAUDE_PLUGIN) || installedPlugins.plugins?.[CLAUDE_PLUGIN]?.length) {
+    return 'global'
+  }
   if (
     existsSync(join(claudeDir, 'helloagents'))
     || hasHelloagentsMarker(join(claudeDir, 'CLAUDE.md'))
-    || hasHelloagentsSettings(join(claudeDir, 'settings.json'))
+    || hasHelloagentsSettings(join(claudeDir, 'settings.json'), 'claude')
   ) {
     return 'standby'
   }
@@ -54,10 +78,19 @@ function detectClaudeMode(home) {
 
 function detectGeminiMode(home) {
   const geminiDir = join(home, '.gemini')
+  const extensionRoot = safeRealTarget(getGeminiExtensionRoot(home)) || normalizePath(getGeminiExtensionRoot(home))
+  const installedExtensionRoot = join(geminiDir, 'extensions', GEMINI_EXTENSION)
+  const installedExtension = safeJson(join(installedExtensionRoot, 'gemini-extension.json')) || {}
+  if (
+    existsSync(installedExtensionRoot)
+    && (safeRealTarget(installedExtensionRoot) === extensionRoot || installedExtension.name === GEMINI_EXTENSION)
+  ) {
+    return 'global'
+  }
   if (
     existsSync(join(geminiDir, 'helloagents'))
     || hasHelloagentsMarker(join(geminiDir, 'GEMINI.md'))
-    || hasHelloagentsSettings(join(geminiDir, 'settings.json'))
+    || hasHelloagentsSettings(join(geminiDir, 'settings.json'), 'gemini')
   ) {
     return 'standby'
   }

package/scripts/cli-lifecycle-hosts.mjs

@@ -1,4 +1,3 @@
-import { spawnSync } from 'node:child_process'
 import { platform } from 'node:os'
 
 import {
@@ -14,11 +13,22 @@ import {
   uninstallCodexGlobal,
   uninstallCodexStandby,
 } from './cli-codex.mjs'
-import { getHostLabel } from './cli-host-detect.mjs'
+import { spawnCommandSync } from './cli-process.mjs'
+import {
+  detectHostMode as detectRuntimeHostMode,
+  getHostLabel,
+} from './cli-host-detect.mjs'
+import {
+  getClaudeMarketplaceRoot,
+  getGeminiExtensionRoot,
+  removeClaudeMarketplaceRoot,
+  removeGeminiExtensionRoot,
+  syncClaudeMarketplaceRoot,
+  syncGeminiExtensionRoot,
+} from './cli-runtime-root.mjs'
 
 const CLAUDE_COMMAND = process.env.HELLOAGENTS_CLAUDE_CMD || 'claude'
 const GEMINI_COMMAND = process.env.HELLOAGENTS_GEMINI_CMD || 'gemini'
-const CLAUDE_MARKETPLACE = 'https://github.com/hellowind777/helloagents.git'
 const CLAUDE_PLUGIN = 'helloagents@helloagents'
 
 function normalizeCommand(command = '') {
@@ -44,11 +54,9 @@ function runHostCommand(command, args) {
   let lastResult = null
 
   for (const candidate of attempts) {
-    const needsShell = process.platform === 'win32' && /\.(cmd|bat)$/i.test(candidate)
-    const result = spawnSync(candidate, args, {
+    const result = spawnCommandSync(candidate, args, {
       encoding: 'utf-8',
       errors: 'replace',
-      shell: needsShell,
       windowsHide: true,
     })
     lastResult = result
@@ -81,8 +89,8 @@ function preserveTrackedModeOnFailure(result = {}, trackedMode = '') {
   return result
 }
 
-function installClaudeGlobalPlugin() {
-  const add = runHostCommand(CLAUDE_COMMAND, ['plugin', 'marketplace', 'add', CLAUDE_MARKETPLACE])
+function installClaudeGlobalPlugin(marketplaceRoot) {
+  const add = runHostCommand(CLAUDE_COMMAND, ['plugin', 'marketplace', 'add', marketplaceRoot])
   if (!add.ok && add.missing) return { ok: false, output: '未找到 claude 命令' }
   const install = runHostCommand(CLAUDE_COMMAND, ['plugin', 'install', CLAUDE_PLUGIN, '--scope', 'user'])
   return { ok: install.ok, output: install.output || add.output }
@@ -158,12 +166,14 @@ function installHostStandby(runtime, host, { previousMode = '' } = {}) {
     const cleanupResult = prepareClaudeStandby(previousMode)
     if (cleanupResult.ok === false) return cleanupResult
     installClaudeStandby(runtime.home, runtime.pkgRoot)
+    if (detectRuntimeHostMode('claude', runtime) !== 'global') removeClaudeMarketplaceRoot(runtime.home)
     return cleanupResult
   }
   if (host === 'gemini') {
     const cleanupResult = prepareGeminiStandby(previousMode)
     if (cleanupResult.ok === false) return cleanupResult
     installGeminiStandby(runtime.home, runtime.pkgRoot)
+    if (detectRuntimeHostMode('gemini', runtime) !== 'global') removeGeminiExtensionRoot(runtime.home)
     return cleanupResult
   }
   if (!installCodexStandby(runtime.home, runtime.pkgRoot)) return { skipped: true }
@@ -174,31 +184,45 @@ function installHostStandby(runtime, host, { previousMode = '' } = {}) {
 function installHostGlobal(runtime, host) {
   if (host === 'claude') {
     uninstallClaudeStandby(runtime.home)
-    return buildNativeResult(
-      installClaudeGlobalPlugin(),
+    const marketplaceRoot = getClaudeMarketplaceRoot(runtime.home)
+    syncClaudeMarketplaceRoot(runtime.pkgRoot, marketplaceRoot)
+    const result = buildNativeResult(
+      installClaudeGlobalPlugin(marketplaceRoot),
       '已自动安装 Claude Code 插件；重启 Claude Code 后生效',
       'Claude Code plugin installed automatically; restart Claude Code to apply',
-      'Claude Code 插件自动安装失败，请在 Claude Code 中执行: /plugin marketplace add https://github.com/hellowind777/helloagents.git；/plugin install helloagents@helloagents',
-      'Claude Code plugin auto-install failed. Run inside Claude Code: /plugin marketplace add https://github.com/hellowind777/helloagents.git; /plugin install helloagents@helloagents',
+      `Claude Code 插件自动安装失败，请在 Claude Code 中执行: /plugin marketplace add "${marketplaceRoot}"；/plugin install helloagents@helloagents`,
+      `Claude Code plugin auto-install failed. Run inside Claude Code: /plugin marketplace add "${marketplaceRoot}"; /plugin install helloagents@helloagents`,
     )
+    return result
   }
   if (host === 'gemini') {
     uninstallGeminiStandby(runtime.home)
-    return buildNativeResult(
-      installGeminiGlobalExtension(runtime.pkgRoot),
+    const extensionRoot = getGeminiExtensionRoot(runtime.home)
+    syncGeminiExtensionRoot(runtime.pkgRoot, extensionRoot)
+    const result = buildNativeResult(
+      installGeminiGlobalExtension(extensionRoot),
       '已自动安装 Gemini CLI 扩展；重启 Gemini CLI 后生效',
       'Gemini CLI extension installed automatically; restart Gemini CLI to apply',
-      `Gemini CLI 扩展自动安装失败，请手动执行: gemini extensions link ${runtime.pkgRoot}`,
-      `Gemini CLI extension auto-install failed. Run manually: gemini extensions link ${runtime.pkgRoot}`,
+      `Gemini CLI 扩展自动安装失败，请手动执行: gemini extensions link "${extensionRoot}"`,
+      `Gemini CLI extension auto-install failed. Run manually: gemini extensions link "${extensionRoot}"`,
     )
+    return result
   }
   uninstallCodexStandby(runtime.home)
   return installCodexGlobal(runtime.home, runtime.pkgRoot) ? {} : { skipped: true }
 }
 
 function cleanupHostStandby(runtime, host) {
-  if (host === 'claude') return { skipped: !uninstallClaudeStandby(runtime.home) }
-  if (host === 'gemini') return { skipped: !uninstallGeminiStandby(runtime.home) }
+  if (host === 'claude') {
+    const skipped = !uninstallClaudeStandby(runtime.home)
+    if (detectRuntimeHostMode('claude', runtime) !== 'global') removeClaudeMarketplaceRoot(runtime.home)
+    return { skipped }
+  }
+  if (host === 'gemini') {
+    const skipped = !uninstallGeminiStandby(runtime.home)
+    if (detectRuntimeHostMode('gemini', runtime) !== 'global') removeGeminiExtensionRoot(runtime.home)
+    return { skipped }
+  }
   const standbyCleaned = uninstallCodexStandby(runtime.home)
   const globalResidueCleaned = uninstallCodexGlobal(runtime.home)
   return { skipped: !(standbyCleaned || globalResidueCleaned) }
@@ -207,7 +231,7 @@ function cleanupHostStandby(runtime, host) {
 function cleanupHostGlobal(runtime, host) {
   if (host === 'claude') {
     uninstallClaudeStandby(runtime.home)
-    return preserveTrackedModeOnFailure(
+    const result = preserveTrackedModeOnFailure(
       buildNativeResult(
         removeClaudeGlobalPlugin(),
         '已自动移除 Claude Code 插件',
@@ -217,10 +241,12 @@ function cleanupHostGlobal(runtime, host) {
       ),
       'global',
     )
+    if (result.ok) removeClaudeMarketplaceRoot(runtime.home)
+    return result
   }
   if (host === 'gemini') {
     uninstallGeminiStandby(runtime.home)
-    return preserveTrackedModeOnFailure(
+    const result = preserveTrackedModeOnFailure(
       buildNativeResult(
         removeGeminiGlobalExtension(),
         '已自动移除 Gemini CLI 扩展',
@@ -230,6 +256,8 @@ function cleanupHostGlobal(runtime, host) {
       ),
       'global',
     )
+    if (result.ok) removeGeminiExtensionRoot(runtime.home)
+    return result
   }
   return { skipped: !uninstallCodexGlobal(runtime.home) }
 }

package/scripts/cli-messages.mjs

@@ -1,5 +1,6 @@
 import { existsSync } from 'node:fs'
 import { join } from 'node:path'
+import { getClaudeMarketplaceRoot, getGeminiExtensionRoot } from './cli-runtime-root.mjs'
 
 export function createMessageHelpers(isCN) {
   const msg = (cn, en) => (isCN ? cn : en)
@@ -19,11 +20,11 @@ function codexGlobalStatus({ home, msg }) {
     : msg('安装 Codex CLI 后重新运行 npm install -g helloagents', 'Install Codex CLI then re-run npm install -g helloagents')
 }
 
-function pluginCommands() {
+function pluginCommands(home) {
   return [
-    '    Claude Code:  /plugin marketplace add https://github.com/hellowind777/helloagents.git',
+    `    Claude Code:  /plugin marketplace add "${getClaudeMarketplaceRoot(home)}"`,
     '                  /plugin install helloagents@helloagents',
-    '    Gemini CLI:   helloagents install gemini --global',
+    `    Gemini CLI:   gemini extensions link "${getGeminiExtensionRoot(home)}"`,
   ].join('\n')
 }
 
@@ -42,24 +43,24 @@ function restartHint(msg) {
 }
 
 function renderInstallMessage(context, mode, state) {
-  const { msg } = context
+  const { home, msg } = context
   const install = state === 'install'
   const refresh = state === 'refresh'
 
   if (mode === 'global') {
     if (install) {
       return msg(
-        `\n  ✅ HelloAGENTS 已安装（global 模式）！\n\n    Claude Code / Gemini CLI: 已自动尝试宿主原生插件/扩展安装\n    Codex:        ${codexGlobalStatus(context)}（~/.agents/plugins/marketplace.json + ~/plugins/helloagents）\n\n  ${restartHint(msg)}\n\n  若宿主命令不可用，请手动执行：\n${pluginCommands()}\n\n  切换模式：\n    helloagents --standby   标准模式（默认，非插件安装）`,
-        `\n  ✅ HelloAGENTS installed (global mode)!\n\n    Claude Code / Gemini CLI: native plugin/extension install attempted automatically\n    Codex:        ${codexGlobalStatus(context)} (~/.agents/plugins/marketplace.json + ~/plugins/helloagents)\n\n  ${restartHint(msg)}\n\n  If a host command is unavailable, run manually:\n${pluginCommands()}\n\n  Switch modes:\n    helloagents --standby   Standby mode (default, non-plugin install)`,
+        `\n  ✅ HelloAGENTS 已安装（global 模式）！\n\n    Claude Code / Gemini CLI: 已自动尝试宿主原生插件/扩展安装\n    Codex:        ${codexGlobalStatus(context)}（~/.agents/plugins/marketplace.json + ~/plugins/helloagents）\n\n  ${restartHint(msg)}\n\n  若宿主命令不可用，请手动执行：\n${pluginCommands(home)}\n\n  切换模式：\n    helloagents --standby   标准模式（默认，非插件安装）`,
+        `\n  ✅ HelloAGENTS installed (global mode)!\n\n    Claude Code / Gemini CLI: native plugin/extension install attempted automatically\n    Codex:        ${codexGlobalStatus(context)} (~/.agents/plugins/marketplace.json + ~/plugins/helloagents)\n\n  ${restartHint(msg)}\n\n  If a host command is unavailable, run manually:\n${pluginCommands(home)}\n\n  Switch modes:\n    helloagents --standby   Standby mode (default, non-plugin install)`,
       )
     }
     return msg(
       refresh
         ? `  global 模式已刷新。\n  Claude Code / Gemini 已自动尝试刷新宿主插件/扩展；Codex 原生本地插件已重装并同步最新文件。\n  ${restartHint(msg)}`
-        : `  所有项目将自动启用完整 HelloAGENTS 规则。\n  Claude Code / Gemini 已自动尝试安装宿主插件/扩展；Codex 已自动安装原生本地插件。\n  ${restartHint(msg)}\n\n若宿主命令不可用，请手动执行：\n${pluginCommands()}`,
+        : `  所有项目将自动启用完整 HelloAGENTS 规则。\n  Claude Code / Gemini 已自动尝试安装宿主插件/扩展；Codex 已自动安装原生本地插件。\n  ${restartHint(msg)}\n\n若宿主命令不可用，请手动执行：\n${pluginCommands(home)}`,
       refresh
         ? `  Global mode refreshed.\n  Claude Code / Gemini native plugin/extension refresh was attempted automatically; Codex native local-plugin files were reinstalled and synced.\n  ${restartHint(msg)}`
-        : `  All projects will use full HelloAGENTS rules.\n  Claude Code / Gemini native plugin/extension install was attempted automatically; Codex now uses the native local-plugin path automatically.\n  ${restartHint(msg)}\n\nIf a host command is unavailable, run manually:\n${pluginCommands()}`,
+        : `  All projects will use full HelloAGENTS rules.\n  Claude Code / Gemini native plugin/extension install was attempted automatically; Codex now uses the native local-plugin path automatically.\n  ${restartHint(msg)}\n\nIf a host command is unavailable, run manually:\n${pluginCommands(home)}`,
     )
   }
 

package/scripts/cli-process.mjs

@@ -0,0 +1,16 @@
+import { spawnSync } from 'node:child_process'
+
+/**
+ * Run a command on all platforms, including Windows .cmd/.bat files, without
+ * relying on child_process shell=true argument concatenation.
+ */
+export function spawnCommandSync(command, args = [], options = {}) {
+  const normalizedArgs = Array.isArray(args) ? args.map((arg) => String(arg)) : []
+  const isWindowsShellScript = process.platform === 'win32' && /\.(cmd|bat)$/i.test(String(command || ''))
+  if (!isWindowsShellScript) {
+    return spawnSync(command, normalizedArgs, options)
+  }
+
+  const comspec = process.env.ComSpec || 'cmd.exe'
+  return spawnSync(comspec, ['/d', '/s', '/c', String(command || ''), ...normalizedArgs], options)
+}

package/scripts/cli-runtime-root.mjs

@@ -1,7 +1,7 @@
 import { copyFileSync, existsSync, mkdtempSync, realpathSync, renameSync } from 'node:fs'
 import { dirname, join, resolve } from 'node:path'
 
-import { copyEntries, ensureDir, removeIfExists } from './cli-utils.mjs'
+import { copyEntries, createLink, ensureDir, removeIfExists } from './cli-utils.mjs'
 
 export const RUNTIME_ROOT_ENTRIES = [
   '.claude-plugin',
@@ -28,6 +28,16 @@ export function getStableRuntimeRoot(home) {
   return join(home, '.helloagents', 'helloagents')
 }
 
+/** Return the Claude local marketplace projection root derived from the shared runtime copy. */
+export function getClaudeMarketplaceRoot(home) {
+  return join(home, '.helloagents', 'host-projections', 'claude-marketplace')
+}
+
+/** Return the Gemini extension projection root derived from the shared runtime copy. */
+export function getGeminiExtensionRoot(home) {
+  return join(home, '.helloagents', 'host-projections', 'gemini')
+}
+
 function normalizePath(path) {
   const resolved = resolve(path)
   try {
@@ -63,17 +73,9 @@ function retryTransientFs(operation) {
   throw lastError
 }
 
-function materializeGeminiHooks(root) {
-  const source = join(root, 'hooks', 'hooks-gemini.json')
-  const target = join(root, 'hooks', 'hooks.json')
-  if (!existsSync(source)) return
-  copyFileSync(source, target)
-}
-
-/** Sync package runtime files into the stable root without copying repo-only files. */
-export function syncRuntimeRoot(sourceRoot, runtimeRoot) {
+function syncRuntimeTree(sourceRoot, targetRoot, { materializeGeminiHooks = false } = {}) {
   const source = resolve(sourceRoot)
-  const target = resolve(runtimeRoot)
+  const target = resolve(targetRoot)
   if (samePath(source, target)) {
     return { synced: false, root: target }
   }
@@ -84,7 +86,13 @@ export function syncRuntimeRoot(sourceRoot, runtimeRoot) {
 
   try {
     copyEntries(source, staging, RUNTIME_ROOT_ENTRIES)
-    materializeGeminiHooks(staging)
+    if (materializeGeminiHooks) {
+      const sourceHooks = join(staging, 'hooks', 'hooks-gemini.json')
+      const targetHooks = join(staging, 'hooks', 'hooks.json')
+      if (existsSync(sourceHooks)) {
+        copyFileSync(sourceHooks, targetHooks)
+      }
+    }
     retryTransientFs(() => {
       removeIfExists(target)
       renameSync(staging, target)
@@ -96,7 +104,42 @@ export function syncRuntimeRoot(sourceRoot, runtimeRoot) {
   }
 }
 
+/** Sync package runtime files into the stable root without copying repo-only files. */
+export function syncRuntimeRoot(sourceRoot, runtimeRoot) {
+  return syncRuntimeTree(sourceRoot, runtimeRoot)
+}
+
+/** Sync a Claude local marketplace root that resolves to the stable runtime copy. */
+export function syncClaudeMarketplaceRoot(sourceRoot, marketplaceRoot) {
+  const source = resolve(sourceRoot)
+  const target = resolve(marketplaceRoot)
+  if (samePath(source, target)) {
+    return { synced: false, root: target }
+  }
+
+  removeIfExists(target)
+  if (createLink(source, target)) {
+    return { synced: true, root: target }
+  }
+  return syncRuntimeTree(source, target)
+}
+
+/** Sync a host-specific extension root derived from the stable runtime copy. */
+export function syncGeminiExtensionRoot(sourceRoot, extensionRoot) {
+  return syncRuntimeTree(sourceRoot, extensionRoot, { materializeGeminiHooks: true })
+}
+
 /** Remove the stable runtime copy while leaving user settings under ~/.helloagents intact. */
 export function removeRuntimeRoot(runtimeRoot) {
   removeIfExists(runtimeRoot)
 }
+
+/** Remove the Claude marketplace projection root. */
+export function removeClaudeMarketplaceRoot(home) {
+  removeIfExists(getClaudeMarketplaceRoot(home))
+}
+
+/** Remove the Gemini extension projection root. */
+export function removeGeminiExtensionRoot(home) {
+  removeIfExists(getGeminiExtensionRoot(home))
+}

package/scripts/cli-toml.mjs

@@ -117,6 +117,10 @@ export function removeTopLevelTomlBlock(text, key) {
   return normalizeToml(`${normalized.slice(0, existing.start)}${normalized.slice(existing.end)}`);
 }
 
+export function hasTopLevelTomlBlock(text, key) {
+  return Boolean(findTopLevelTomlBlock(text, key));
+}
+
 export function prependTopLevelTomlBlocks(text, blocks) {
   const normalizedBlocks = blocks
     .map((block) => String(block || '').trim())