create-dwy 0.23.0 → 0.24.1

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # create-dwy
 
+## [0.24.1] - 2026-11-03
+
+### Patch Changes
+
+- 包含 0.24.0 的 Skills / Hooks / Rules / 通用规范管理、显式移除和全局去重能力。
+- 收敛配置管理集成测试的无断言日志，规避 Node 22 测试运行器在大量中文 stdout 下的 IPC 反序列化问题；保留全部断言和真实终端输出测试，不改变 CLI 行为。
+
+---
+
+## [0.24.0] - 2026-11-03
+
+### Minor Changes
+
+- 全局提供 Skills、Hooks 和 AGENTS.md 通用规范，项目另外提供 Rules。全局首次默认启用通用规范；Hooks 与规范增加显式启用/更新和移除动作，未选择的类型保持原样，规范移除后不自动复选。
+- 项目通用规范与 Rules 分别操作各自托管块，移除任一项保留其他内容。任一所选 CLI 已有有效全局基线时，项目禁止重复安装，共享项目文件的混合平台场景提示补齐缺失的全局入口。
+- Hooks 按有效脚本及对应事件、matcher 和完整命令注册判断全局提供者，项目只补缺失项。全局启用后明确清理当前项目重复脚本和注册项；移除全局配置不自动回填项目。
+- Hook 清理支持历史托管项，保留同名个人路径、组合命令和其他设置；配置目录及单文件链接在规划和执行时检查，防止项目操作穿透改写全局或外部目标。
+- 补充配置独立启停、移除记忆、继承、取消及真实终端回归，旧测试统一注入临时用户目录。
+
+---
+
 ## [0.23.0] - 2026-11-02
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-dwy",
-  "version": "0.23.0",
+  "version": "0.24.1",
   "description": "项目脚手架与多平台 AI 配置同步工具",
   "type": "module",
   "bin": {

package/src/cli-help.js

@@ -25,10 +25,10 @@ export function buildHelpText(version) {
     '同步步骤：',
     '  1. 选择同步范围：当前项目或全局。',
     '  2. 选择该范围支持的平台；全局不提供 Cursor。',
-    '  3. 选择本次处理内容，默认只选 Skills；未选择的类型保持原样。',
-    '     项目：Skills、项目 Rules、Hooks；全局：Skills、全局通用规范、Hooks。',
-    '     内容选项按平台能力过滤。Hooks 选中类型后按平台自动处理。',
-    '  4. 逐项选择 Skills / 项目 Rules；全局通用规范显示摘要。',
+    '  3. 选择本次处理内容；项目默认只选 Skills，全局首次默认 Skills 和通用规范。',
+    '     项目：Skills、Hooks、Rules、AGENTS.md 通用规范；全局：Skills、Hooks、AGENTS.md 通用规范。',
+    '     内容按平台能力过滤；未选择的类型保持原样。',
+    '  4. 逐项选择 Skills / Rules；Hooks 和通用规范分别选择启用/更新或移除。',
     '  5. 查看写入、备份和清理清单，确认后执行；取消不写文件。',
     '  Commands 不参与同步。',
     '',
@@ -39,7 +39,8 @@ export function buildHelpText(version) {
     '',
     '常见用法：',
     '  同步当前项目：cd your-project 后执行 dwy，选择「当前项目」及本次处理内容。',
-    '  同步全局：执行 dwy，选择「全局」及 Skills、全局通用规范或 Hooks。',
+    '  同步全局：执行 dwy，选择「全局」及 Skills、Hooks 或 AGENTS.md 通用规范。',
+    '  移除配置：选择对应范围和 Hooks / 通用规范，再选择「移除」并确认。',
     '  更新或调整配置：再次执行 dwy sync，检查勾选项，再确认同步。',
     '  更新 CLI：dwy upgrade（全局安装时可用；更新后执行 dwy --version 查看版本）。',
     '  迁移老项目：cd your-project 后执行 dwy migrate，无需重新勾选。',
@@ -58,6 +59,12 @@ export function buildHelpText(version) {
     'Skills 副本集中在 ~/.dwy/skills；项目和全局使用目录链接，同平台全局入口优先。',
     '项目 Skills 全部适用平台均有全局入口时显示「全局已启用」，不能重复勾选。',
     '部分平台已有全局入口时仍可选，只为缺少全局入口的平台安装项目链接。',
+    'Hooks 与 Skills 独立；整组管理，项目仅安装缺少有效全局注册的 Hooks。',
+    '全局 Hook 的脚本与对应事件、matcher、完整命令注册均有效时，项目禁止重复安装。',
+    '任一所选 CLI 已有 dwy 全局通用规范时，项目只能继承并清理重复基线；其他 CLI 需补齐全局规范。',
+    '手写 AGENTS.md 本身不算全局已安装；通用规范与 Rules 共用文件但独立管理。',
+    '移除通用规范仅删除基线块，保留 Rules 和手写内容；移除后不会因默认值自动重新启用。',
+    '全局启用会明确列出当前项目重复项清理；全局移除不会自动向项目补装。',
     '项目同步只清理项目重复入口，不改全局提供者；真实目录先备份。',
     'sync / migrate 仅准备缺失或损坏副本，不刷新已有共享内容；refresh / upgrade 才刷新。',
     '产品流程缺失的外部依赖也列入清单，确认后联网补齐，已有内容保留。',

package/src/sync-all.js

@@ -6,12 +6,13 @@ import { SEARCH_PLACEHOLDER, searchableMultiselect, searchableSelect } from './s
 import { normalizeSkillScope, resolveProjectSkillDir, resolveGlobalSkillDir, copySkillsToProjectPlatforms, deduplicateProjectSkills } from './sync-global-skills.js'
 import { ensureSharedSkills } from './skill-store.js'
 import { chalk } from './utils.js'
-import { interactiveSelect, readBaselineDoc, resolveSourceDir, scanExisting, scanHooks, scanRules, scanSkills } from './sync.js'
+import { interactiveSelect, loadHookManifests, readBaselineDoc, resolveSourceDir, scanExisting, scanHooks, scanRules, scanSkills } from './sync.js'
 import { parseManagedRuleNames, scanExistingCodexHooks, scanExistingCodexSkills } from './sync-codex.js'
 import { scanExistingCursorRules } from './sync-cursor.js'
 import { installSkills } from './skills-install.js'
 import { selfUpgrade } from './self-upgrade.js'
 import { buildSyncPlan, contentOptions, projectSkillChoices, PLATFORM_LABELS, PLATFORM_SYNC_TYPES } from './sync-plan.js'
+import { assertConfigPath, baselineProviders, globalHookNames } from './sync-inheritance.js'
 
 const PLATFORM_OPTIONS = [
   { value: 'claude', label: 'Claude Code', description: '支持 Skills、项目 Rules、Hooks 和全局通用规范' },
@@ -126,7 +127,7 @@ function staleEntries(scans, state, existing, platforms) {
   const result = {}
   for (const platform of platforms) {
     result[platform] = {}
-    for (const type of PLATFORM_SYNC_TYPES[platform]) {
+    for (const type of PLATFORM_SYNC_TYPES[platform].filter(type => current[type])) {
       result[platform][type] = (state.platforms[platform]?.[type] || []).filter(name =>
         !current[type].has(name) && existing[platform][type].has(platform === 'cursor' && type === 'rules' ? buildCursorRuleName(name) : name))
     }
@@ -134,6 +135,14 @@ function staleEntries(scans, state, existing, platforms) {
   return result
 }
 
+/** 全局首次默认管理基线；任一所选平台显式移除后不再整组默认开启。 */
+export function defaultContentTypes(scope, platforms, state) {
+  const allowed = new Set(contentOptions(scope, platforms).map(option => option.value))
+  const result = allowed.has('skills') ? ['skills'] : []
+  if (scope === 'global' && allowed.has('baseline') && platforms.every(platform => state.platforms[platform]?.baseline !== false)) result.push('baseline')
+  return result
+}
+
 function normalizeRemovals(raw) {
   return Object.fromEntries(Object.entries(raw).map(([platform, types]) => [platform,
     Object.fromEntries(Object.entries(types).map(([type, names]) => [type, new Set(names)]))]))
@@ -220,6 +229,7 @@ export async function syncAll({
   selectedPlatforms: platformsOverride, contentTypes: typesOverride, staleRemovals: removalsOverride,
   skillScope: skillScopeOverride, syncMode: modeOverride, homeDir = os.homedir(),
   codexHome = process.env.CODEX_HOME || path.join(homeDir, '.codex'), scope: scopeOverride, confirmed,
+  contentActions: actionsOverride,
 } = {}) {
   const sourceDir = sourceDirOverride || await resolveSourceDir()
   if (!await fs.pathExists(sourceDir)) throw new Error('ai-tools templates not found in repo')
@@ -227,8 +237,8 @@ export async function syncAll({
   const scope = scopeOverride || (selectedOverride || platformsOverride ? 'project' : await searchableSelect({
     message: '选择同步范围',
     options: [
-      { value: 'project', label: '当前项目', description: '管理项目启用的 Skills、项目 Rules 和 Hooks；全局已有 Skills 自动去重' },
-      { value: 'global', label: '全局', description: '管理用户级 Skills、通用规范和 Hooks；项目重复 Skill 入口会明确列出清理项' },
+      { value: 'project', label: '当前项目', description: '管理 Skills、Hooks、Rules 和通用规范；继承有效全局配置' },
+      { value: 'global', label: '全局', description: '管理 Skills、Hooks 和通用规范；清理当前项目重复入口' },
     ], initialValue: 'project',
   }))
   if (isCancel(scope)) { console.log(chalk.yellow('已取消同步。')); return }
@@ -239,13 +249,15 @@ export async function syncAll({
   if (platforms.length === 0 || platforms.some(platform => !PLATFORM_SYNC_TYPES[platform] || (global && platform === 'cursor'))) throw new Error('所选平台不支持此同步范围')
   const options = contentOptions(scope, platforms)
   const allowed = new Set(options.map(option => option.value))
+  const projectState = await loadSyncState(projectDir), globalState = await loadSyncState(homeDir)
+  const targetState = global ? globalState : projectState
   let contentTypes = typesOverride
   if (!contentTypes && modeOverride === SYNC_MODE_SKILLS) contentTypes = ['skills']
   if (!contentTypes && selectedOverride) contentTypes = Object.keys(selectedOverride).filter(type => allowed.has(type))
   if (!contentTypes) {
     const result = await searchableMultiselect({
       message: '选择本次处理内容（未勾选的类型保持原样）', options,
-      initialValues: allowed.has('skills') ? ['skills'] : [], required: true, maxItems: 5,
+      initialValues: defaultContentTypes(scope, platforms, targetState), required: true, maxItems: 5,
     })
     if (isCancel(result)) { console.log(chalk.yellow('已取消同步。')); return }
     contentTypes = result
@@ -253,8 +265,6 @@ export async function syncAll({
   if (contentTypes.some(type => !allowed.has(type))) throw new Error('所选范围或平台不支持此同步内容')
   if (contentTypes.length === 0) { console.log('未选择处理内容。'); return }
   const scans = { skills: await scanSkills(sourceDir), rules: await scanRules(sourceDir), hooks: await scanHooks(sourceDir), commands: [] }
-  const projectState = await loadSyncState(projectDir), globalState = await loadSyncState(homeDir)
-  const targetState = global ? globalState : projectState
   const existing = await managedNames(targetRoot, global, codexHome)
   const current = Object.fromEntries(['skills', 'rules', 'hooks'].map(type => [type,
     unionSets(...platforms.map(platform => existing[platform][type]))]))
@@ -266,12 +276,45 @@ export async function syncAll({
     ? { skills: selectedOverride.skills || [], rules: selectedOverride.rules || [], hooks: [], commands: [] }
     : await interactiveSelect(choices, defaults, { types: contentTypes })
   if (selected === null) { console.log(chalk.yellow('已取消同步。')); return }
+  const contentActions = { ...actionsOverride }
+  if (!selectedOverride) {
+    for (const type of ['hooks', 'baseline'].filter(type => contentTypes.includes(type))) {
+      if (contentActions[type]) continue
+      const inherited = type === 'baseline' && !global ? await baselineProviders(platforms, { homeDir, codexHome }) : []
+      const name = type === 'hooks' ? 'Hooks' : 'AGENTS.md 通用规范'
+      if (inherited.length) console.log(chalk.yellow(`全局已启用通用规范：${inherited.map(p => PLATFORM_LABELS[p]).join('、')}；项目禁止重复安装，其他平台需补齐全局规范。`))
+      let inheritedHooks = false
+      if (type === 'hooks' && !global) {
+        const manifests = await loadHookManifests(sourceDir)
+        let total = 0, covered = 0
+        for (const platform of platforms.filter(p => PLATFORM_SYNC_TYPES[p].includes('hooks'))) {
+          const available = scans.hooks.filter(hook => manifests.some(manifest => manifest.name === hook.name && (!manifest.platforms || manifest.platforms.includes(platform))))
+          const provided = await globalHookNames({ platform, sourceDir, homeDir, codexHome })
+          total += available.length
+          covered += available.filter(hook => provided.has(hook.name)).length
+          if (provided.size) console.log(`${PLATFORM_LABELS[platform]} Hooks 全局已启用：${[...provided].join('、')}`)
+        }
+        inheritedHooks = total > 0 && covered === total
+      }
+      const action = await searchableSelect({
+        message: `选择 ${name} 操作`, initialValue: 'sync',
+        options: [
+          { value: 'sync', label: inherited.length ? '使用全局，仅清理项目重复基线' : inheritedHooks ? '使用全局，仅清理项目重复 Hooks' : '启用 / 更新',
+            description: type === 'hooks' && !global ? '只为缺少有效全局注册的 Hook 安装项目配置，其他仅去重' : '执行清单会列出实际路径及清理项' },
+          { value: 'remove', label: `移除当前范围的${name}`, description: '只移除 dwy 托管内容，保留个人配置和其他类型' },
+        ],
+      })
+      if (isCancel(action)) { console.log(chalk.yellow('已取消同步。')); return }
+      contentActions[type] = action
+    }
+  }
   const stale = staleEntries(scans, targetState, existing, platforms)
   const removals = normalizeRemovals(removalsOverride || stale)
   const baseline = contentTypes.some(type => type === 'rules' || type === 'baseline') ? await readBaselineDoc(sourceDir) : ''
   const plan = await buildSyncPlan({
     scope, platforms, contentTypes, selected, scans, sourceDir, projectDir, homeDir, codexHome,
     projectState, globalState, staleRemovals: removals, staleEntries: stale, baseline,
+    contentActions,
     skillScope: normalizeSkillScope(skillScopeOverride),
   })
   const nextTarget = global ? plan.nextGlobal : plan.nextProject
@@ -279,16 +322,21 @@ export async function syncAll({
   nextTarget.syncMode = contentTypes.length === 1 && contentTypes[0] === 'skills' ? SYNC_MODE_SKILLS : SYNC_MODE_ALL
   nextTarget.skillScope = normalizeSkillScope(skillScopeOverride)
   const stateFile = path.join(targetRoot, ...SYNC_STATE_PATH)
-  plan.operations.push({ kind: 'state', label: '更新当前范围同步记录', paths: [stateFile], run: () => saveSyncState(targetRoot, nextTarget) })
+  await assertConfigPath(stateFile, targetRoot)
+  plan.operations.push({ kind: 'state', label: '更新当前范围同步记录', paths: [stateFile], run: async () => {
+    await assertConfigPath(stateFile, targetRoot)
+    await saveSyncState(targetRoot, nextTarget)
+  } })
   if (global && plan.projectChanged) plan.operations.push({
     kind: 'state', label: '更新项目去重记录', paths: [path.join(projectDir, ...SYNC_STATE_PATH)],
-    run: () => saveSyncState(projectDir, plan.nextProject),
+    run: async () => { await assertConfigPath(path.join(projectDir, ...SYNC_STATE_PATH), projectDir); await saveSyncState(projectDir, plan.nextProject) },
   })
+  if (global && plan.projectChanged) await assertConfigPath(path.join(projectDir, ...SYNC_STATE_PATH), projectDir)
   console.log(`\n同步范围：${global ? '全局' : '当前项目'}；平台：${platforms.map(p => PLATFORM_LABELS[p]).join('、')}`)
   console.log(`处理内容：${contentTypes.map(type => options.find(option => option.value === type).label).join('、')}`)
   if (contentTypes.includes('skills')) console.log(`Skills：${selected.skills.map(item => item.name).join('、') || '无项目安装选择；已有全局入口仅去重'}`)
   if (contentTypes.includes('rules')) console.log(`Rules：${selected.rules.map(item => item.name).join('、') || '移除当前项目托管规则'}`)
-  if (contentTypes.includes('baseline')) console.log(`全局通用规范摘要：${baseline.split('\n').filter(line => /^#/.test(line)).slice(0,3).join('；')}`)
+  if (contentTypes.includes('baseline')) console.log(`通用规范：${contentActions.baseline === 'remove' ? '显式移除' : baseline.split('\n').filter(line => /^#/.test(line)).slice(0,3).join('；')}`)
   for (const operation of plan.operations) {
     console.log(operation.label)
     for (const dest of operation.paths) console.log(`  → ${dest}`)

package/src/sync-codex.js

@@ -111,19 +111,30 @@ function upsertBaselineBlock(content, baselineBody) {
   return base ? `${block}\n\n${base}` : `${block}\n`
 }
 
-/** 更新 CLI 全局基线，仅替换 dwy 托管块，并清除旧版写入的项目 Rules 托管块。 */
-export async function syncGlobalBaselineDoc(baseline, dest) {
-  if (!baseline.trim()) return 0
+/** 判断文件是否含有有效的 dwy 通用规范；个人文件不作为继承依据。 */
+export async function hasManagedBaseline(dest) {
+  if (!await fs.pathExists(dest)) return false
+  const match = (await fs.readFile(dest, 'utf8')).match(BASELINE_RE)
+  return Boolean(match && match[0].replace(/<!--[\s\S]*?-->/g, '').trim())
+}
+
+/** 独立更新通用规范，空内容移除基线块；保留 Rules 和个人内容。 */
+export async function syncBaselineDoc(baseline, dest) {
   const current = await fs.pathExists(dest) ? await fs.readFile(dest, 'utf-8') : ''
-  const previous = current.trim() === baseline.trim() ? '' : current
-  const next = upsertManagedBlock(upsertBaselineBlock(previous, baseline), '')
+  const previous = baseline.trim() && current.trim() === baseline.trim() ? '' : current
+  const next = upsertBaselineBlock(previous, baseline)
   if (next === current) return 0
-  await fs.ensureDir(path.dirname(dest))
-  await fs.writeFile(dest, next)
-  logAction(`global baseline → ${dest}`)
+  if (next.trim()) {
+    await fs.ensureDir(path.dirname(dest))
+    await fs.writeFile(dest, next)
+  } else await fs.remove(dest)
+  logAction(`baseline → ${dest}`)
   return 1
 }
 
+/** 兼容旧调用方；全局基线更新同样保留其他托管块。 */
+export const syncGlobalBaselineDoc = syncBaselineDoc
+
 /** 迁移旧入口中的基线；无托管标记时只移除与当前模板完全一致的文件。 */
 export async function removeLegacyBaseline(baseline, dest) {
   if (!await fs.pathExists(dest)) return
@@ -153,7 +164,7 @@ export async function syncProjectAgentsMd(projectDir, selectedRules, {
   }
   const blockBody = sections.join('\n\n---\n\n')
 
-  const next = upsertManagedBlock(upsertBaselineBlock(current, ''), blockBody)
+  const next = upsertManagedBlock(current, blockBody)
   if (next === current) return 0
   await fs.ensureDir(path.dirname(dest))
   await fs.writeFile(dest, next)
@@ -253,7 +264,8 @@ function globalHookCommand(configDir, name) {
   return `bash '${script.replace(/'/g, "'\\''")}'`
 }
 
-function buildCodexHooksJson(manifests, selectedHookNames, global, configDir) {
+/** 生成 Codex Hook 注册，继承检测和写入共用相同命令格式。 */
+export function buildCodexHooksJson(manifests, selectedHookNames, global, configDir) {
   const hooksJson = { hooks: {} }
   const grouped = new Map()
 
@@ -284,14 +296,19 @@ function buildCodexHooksJson(manifests, selectedHookNames, global, configDir) {
   return Object.keys(hooksJson.hooks).length > 0 ? hooksJson : {}
 }
 
-function isManagedCodexHookCommand(command, managedHookNames, configDir) {
+/** 只识别完整生成命令及已知历史格式，保留同名个人路径。 */
+export function isManagedCodexHookCommand(command, managedHookNames, configDir) {
   if (typeof command !== 'string') return false
-  const match = command.match(/\.codex\/hooks\/([^\s'"]+)/)
-  return !!(match && managedHookNames.has(match[1]))
-    || [...managedHookNames].some(name => command === globalHookCommand(configDir, name))
+  return [...managedHookNames].some(name => [
+    globalHookCommand(configDir, name),
+    `bash "$(git rev-parse --show-toplevel)/.codex/hooks/${name}"`,
+    `bash "$HOME/.codex/hooks/${name}"`,
+    `bash ~/.codex/hooks/${name}`,
+  ].includes(command))
 }
 
-function mergeCodexHooks(existingHooks, generatedHooks, managedHookNames, configDir) {
+/** 只替换指定托管注册，保留其他命令及配置字段。 */
+export function mergeCodexHooks(existingHooks, generatedHooks, managedHookNames, configDir) {
   const merged = {}
   const sourceEvents = new Set([
     ...Object.keys(existingHooks || {}),
@@ -313,14 +330,12 @@ function mergeCodexHooks(existingHooks, generatedHooks, managedHookNames, config
   return Object.keys(merged).length > 0 ? merged : undefined
 }
 
-async function syncCodexHooksJson(sourceDir, configDir, selectedHookNames, global) {
+async function syncCodexHooksJson(sourceDir, configDir, selectedHookNames, global, staleHookNames) {
   const dest = path.join(configDir, 'hooks.json')
   const manifests = await loadHookManifests(sourceDir)
   const generated = buildCodexHooksJson(manifests, selectedHookNames, global, configDir)
   const managedHookNames = new Set(
-    manifests
-      .filter(manifest => !manifest.platforms || manifest.platforms.includes('codex'))
-      .map(manifest => manifest.name),
+    [...manifests.map(manifest => manifest.name), ...staleHookNames],
   )
 
   let nextJson
@@ -402,7 +417,7 @@ export async function syncCodex({
   }
   if (syncTypes.includes('hooks')) {
     syncedCount += await copyCodexHooks(syncedSelection.hooks, configDir)
-    syncedCount += await syncCodexHooksJson(sourceDir, configDir, selectedHookNames, global)
+    syncedCount += await syncCodexHooksJson(sourceDir, configDir, selectedHookNames, global, staleRemovals.hooks || [])
   }
 
   const skillTemplateNames = new Set([

package/src/sync-inheritance.js

@@ -0,0 +1,119 @@
+import fs from 'fs-extra'
+import path from 'node:path'
+import { buildClaudeHooksSettings, isManagedClaudeHookCommand, mergeClaudeHooks, loadHookManifests, scanHooks } from './sync.js'
+import { buildCodexHooksJson, hasManagedBaseline, isManagedCodexHookCommand, mergeCodexHooks } from './sync-codex.js'
+
+/** Hook 配置文件名由平台决定，Codex 根目录由调用方解析。 */
+export function hookConfigFile(platform, root) {
+  return path.join(root, platform === 'claude' ? 'settings.json' : 'hooks.json')
+}
+
+async function readHookConfig(platform, root) {
+  const file = hookConfigFile(platform, root)
+  if (!await fs.pathExists(file)) return {}
+  const config = await fs.readJson(file)
+  if (!config || typeof config !== 'object' || Array.isArray(config)
+    || (config.hooks !== undefined && (!config.hooks || typeof config.hooks !== 'object' || Array.isArray(config.hooks)))) {
+    throw new Error(`Hook 配置格式无效：${file}`)
+  }
+  for (const configs of Object.values(config.hooks || {})) {
+    if (!Array.isArray(configs) || configs.some(cfg => !cfg || typeof cfg !== 'object' || !Array.isArray(cfg.hooks)
+      || cfg.hooks.some(hook => !hook || typeof hook !== 'object'))) throw new Error(`Hook 配置格式无效：${file}`)
+  }
+  return config
+}
+
+/** 查找待移除名称的托管注册；不要求脚本仍在，便于清理坏配置。 */
+export async function hasManagedHookConfig(platform, root, names) {
+  const config = await readHookConfig(platform, root)
+  const matches = platform === 'claude' ? isManagedClaudeHookCommand : isManagedCodexHookCommand
+  return Object.values(config.hooks || {}).some(configs => configs.some(cfg => cfg.hooks.some(hook => matches(hook.command, names, root))))
+}
+
+/** 不隐式改变用户的全局禁用开关；启用前明确报告冲突。 */
+export async function assertHooksEnabled(platform, root) {
+  if ((await readHookConfig(platform, root)).disableAllHooks === true) throw new Error(`Hooks 被 disableAllHooks 禁用，无法启用：${hookConfigFile(platform, root)}`)
+}
+
+/** 只移除指定托管脚本和注册，不补装或更新其他 Hooks。 */
+export async function removeManagedHooks(platform, root, names, paths) {
+  const file = hookConfigFile(platform, root)
+  if (paths.includes(file)) {
+    const config = await readHookConfig(platform, root)
+    const merge = platform === 'claude' ? mergeClaudeHooks : mergeCodexHooks
+    const nextHooks = merge(config.hooks, undefined, names, root)
+    const next = { ...config }
+    if (nextHooks) next.hooks = nextHooks
+    else delete next.hooks
+    if (JSON.stringify(config) !== JSON.stringify(next)) {
+      if (Object.keys(next).length) await fs.writeJson(file, next, { spaces: 2 })
+      else await fs.remove(file)
+    }
+  }
+  for (const dest of paths) if (dest !== file) await fs.remove(dest)
+}
+
+/** 解析通用规范的原生全局入口；Cursor 没有文件入口。 */
+export function globalBaselinePath(platform, homeDir, codexHome) {
+  return { claude: path.join(homeDir, '.claude', 'CLAUDE.md'), codex: path.join(codexHome, 'AGENTS.md'),
+    opencode: path.join(homeDir, '.config', 'opencode', 'AGENTS.md') }[platform]
+}
+
+/** 返回所选 CLI 中实际提供 dwy 全局通用规范的平台。 */
+export async function baselineProviders(platforms, { homeDir, codexHome }) {
+  const providers = []
+  for (const platform of platforms) {
+    const dest = globalBaselinePath(platform, homeDir, codexHome)
+    if (dest && await hasManagedBaseline(dest)) providers.push(platform)
+  }
+  return providers
+}
+
+/** 全局 Hook 必须在对应事件及 matcher 下注册了完整执行命令，且脚本仍有效。 */
+export async function globalHookNames({ platform, sourceDir, homeDir, codexHome }) {
+  if (!['claude', 'codex'].includes(platform)) return new Set()
+  const root = platform === 'claude' ? path.join(homeDir, '.claude') : codexHome
+  const config = await readHookConfig(platform, root)
+  if (config.disableAllHooks === true) return new Set()
+  const manifests = await loadHookManifests(sourceDir)
+  const result = new Set()
+  for (const hook of await scanHooks(sourceDir)) {
+    const names = new Set([hook.name])
+    const generated = platform === 'claude' ? buildClaudeHooksSettings(manifests, names, true)
+      : buildCodexHooksJson(manifests, names, true, root)
+    const registrations = Object.entries(generated.hooks || {}).flatMap(([event, configs]) =>
+      configs.flatMap(cfg => cfg.hooks.map(command => ({ event, matcher: cfg.matcher, command: command.command }))))
+    if (registrations.length === 0) continue
+    const registered = registrations.every(expected => {
+      const configs = config.hooks?.[expected.event] || []
+      return configs.some(cfg => cfg.matcher === expected.matcher && Array.isArray(cfg.hooks)
+        && cfg.hooks.some(item => item.type === 'command' && item.command === expected.command))
+    })
+    if (!registered) continue
+    const stat = await fs.stat(path.join(root, 'hooks', hook.name)).catch(error => {
+      if (['ENOENT', 'ENOTDIR', 'ELOOP'].includes(error.code)) return null
+      throw error
+    })
+    if (stat?.isFile()) result.add(hook.name)
+  }
+  return result
+}
+
+/** 配置写入与清理不能穿透边界内的目录或文件链接；确认前及执行时均检查。 */
+export async function assertConfigPath(dest, root) {
+  const nearest = async start => {
+    let current = start
+    while (!await fs.lstat(current).catch(error => { if (error.code === 'ENOENT') return null; throw error })) current = path.dirname(current)
+    return current
+  }
+  const base = await nearest(root)
+  const expectedRoot = path.resolve(await fs.realpath(base), path.relative(base, root))
+  const entry = await nearest(dest)
+  const expected = path.resolve(expectedRoot, path.relative(root, entry))
+  let actual
+  try { actual = await fs.realpath(entry) } catch (error) {
+    if (!['ENOENT', 'ELOOP', 'ENOTDIR'].includes(error.code)) throw error
+    throw new Error(`配置入口为无效链接，保留原入口：${entry}`)
+  }
+  if (actual !== expected) throw new Error(`配置入口链接指向外部位置，保留原入口：${entry}`)
+}

package/src/sync-plan.js

@@ -3,16 +3,17 @@ import path from 'node:path'
 import { ensureSharedSkills, linkSkill, removeSkillEntry } from './skill-store.js'
 import { findGlobalSkill, globalSkillRoots, resolveGlobalSkillDir, resolveProjectSkillDir } from './sync-global-skills.js'
 import { loadHookManifests, syncClaude } from './sync.js'
-import { removeLegacyBaseline, syncCodex, syncGlobalBaselineDoc, syncProjectAgentsMd } from './sync-codex.js'
+import { hasManagedBaseline, removeLegacyBaseline, syncBaselineDoc, syncCodex, syncProjectAgentsMd } from './sync-codex.js'
 import { syncCursor } from './sync-cursor.js'
 import { planMissingExternalSkills } from './skills-install.js'
+import { assertConfigPath, assertHooksEnabled, baselineProviders, globalBaselinePath, globalHookNames, hasManagedHookConfig, hookConfigFile, removeManagedHooks } from './sync-inheritance.js'
 
 /** 平台显示名，交互和变更清单共用。 */
 export const PLATFORM_LABELS = { claude: 'Claude Code', codex: 'Codex', opencode: 'OpenCode', cursor: 'Cursor' }
-/** 项目范围的平台能力；全局范围用通用规范替代项目 Rules，且不支持 Cursor。 */
+/** 平台能力；全局不提供 Rules，Cursor 仅提供项目 Rules。 */
 export const PLATFORM_SYNC_TYPES = {
-  claude: ['skills', 'rules', 'hooks'], codex: ['skills', 'rules', 'hooks'],
-  opencode: ['skills', 'rules'], cursor: ['rules'],
+  claude: ['skills', 'rules', 'hooks', 'baseline'], codex: ['skills', 'rules', 'hooks', 'baseline'],
+  opencode: ['skills', 'rules', 'baseline'], cursor: ['rules'],
 }
 
 /** 只提供所选范围和平台支持的内容；未勾选类型不进入清理或状态更新。 */
@@ -21,8 +22,9 @@ export function contentOptions(scope, platforms) {
   return [
     ...(supports('skills') ? [{ value: 'skills', label: 'Skills', description: '管理当前范围的启用入口；已有共享内容不刷新' }] : []),
     ...(scope === 'project' && supports('rules') ? [{ value: 'rules', label: '项目规则（Rules）', description: '只更新当前项目的托管规则' }] : []),
-    ...(scope === 'global' ? [{ value: 'baseline', label: '全局通用规范', description: '更新所选工具的原生全局指令入口，不修改项目规则' }] : []),
-    ...(supports('hooks') ? [{ value: 'hooks', label: 'Hooks（按平台自动同步）', description: '仅选择此类型后，自动同步所选平台支持的 Hooks' }] : []),
+    ...(supports('baseline') ? [{ value: 'baseline', label: 'AGENTS.md 通用规范', description: scope === 'global'
+      ? '管理原生全局指令入口；首次默认启用，可显式移除' : '管理项目基线块；已有全局规范时仅可清理重复项' }] : []),
+    ...(supports('hooks') ? [{ value: 'hooks', label: 'Hooks', description: '独立启用或移除整组；项目继承有效全局注册' }] : []),
   ]
 }
 
@@ -72,6 +74,7 @@ function ownedGlobalRoots(platform, homeDir, codexHome) {
 export async function buildSyncPlan({
   scope, platforms, contentTypes, selected, scans, sourceDir, projectDir, homeDir, codexHome,
   projectState, globalState, staleRemovals = {}, staleEntries = {}, baseline,
+  contentActions = {},
   skillScope = { destinations: ['project'], globalSkills: [] },
 }) {
   const global = scope === 'global'
@@ -85,7 +88,10 @@ export async function buildSyncPlan({
   if (platforms.some(platform => !PLATFORM_SYNC_TYPES[platform] || (global && platform === 'cursor'))
     || contentTypes.some(type => !allowed.has(type))) throw new Error('所选范围或平台不支持此同步内容')
   const active = new Set(contentTypes)
-  if (active.has('baseline') && !baseline.trim()) throw new Error('没有可同步的全局通用规范')
+  for (const [type, action] of Object.entries(contentActions)) {
+    if (!['baseline', 'hooks'].includes(type) || !['sync', 'remove'].includes(action)) throw new Error('无效的内容操作')
+  }
+  if (active.has('baseline') && contentActions.baseline !== 'remove' && !baseline.trim()) throw new Error('没有可同步的通用规范')
   const operations = []
   const nextProject = structuredClone(projectState), nextGlobal = structuredClone(globalState)
   const targetState = global ? nextGlobal : nextProject
@@ -96,7 +102,18 @@ export async function buildSyncPlan({
   const addedGlobalPaths = new Set(), removedGlobalPaths = new Set()
   const localCleanup = new Set()
   let projectChanged = !global && contentTypes.length > 0
-  const add = (kind, label, paths, run) => operations.push({ kind, label, paths, run })
+  const add = (kind, label, paths, run) => {
+    // 无标记旧基线须在 Rules 追加前识别，否则原文会变成无法确认归属的混合内容。
+    const beforeRules = ['baseline', 'remove-baseline'].includes(kind) ? operations.findIndex(operation => operation.kind === 'rules') : -1
+    operations.splice(beforeRules < 0 ? operations.length : beforeRules, 0, { kind, label, paths, run })
+  }
+  const addConfig = async (kind, label, paths, boundary, run) => {
+    for (const dest of paths) await assertConfigPath(dest, boundary)
+    add(kind, label, paths, async () => {
+      for (const dest of paths) await assertConfigPath(dest, boundary)
+      await run()
+    })
+  }
   const platformState = platform => targetState.platforms[platform] ||= { skills: [], rules: [], hooks: [], commands: [] }
   const approved = (platform, type) => [...(staleRemovals[platform]?.[type] || [])].filter(safeName)
   const retained = (platform, type) => (staleEntries[platform]?.[type] || []).filter(name => safeName(name) && !approved(platform, type).includes(name))
@@ -196,7 +213,7 @@ export async function buildSyncPlan({
     const rules = scans.rules.filter(rule => selectedNames.has(rule.name))
     const preserved = new Set(cliPlatforms.flatMap(platform => retained(platform, 'rules')))
     if (cliPlatforms.length) {
-      add('rules', '更新项目 Rules（保留手写内容）', [path.join(projectDir, 'AGENTS.md')],
+      await addConfig('rules', '更新项目 Rules（保留通用规范和手写内容）', [path.join(projectDir, 'AGENTS.md')], projectDir,
         () => syncProjectAgentsMd(projectDir, rules, { preservedRuleNames: preserved }))
       const names = [...new Set([...rules.map(rule => rule.name), ...preserved])].sort()
       for (const platform of ['claude', 'codex', 'opencode']) {
@@ -220,58 +237,110 @@ export async function buildSyncPlan({
         const dest = path.join(projectDir, '.claude', 'rules', name)
         if (safeName(name) && await existsEntry(dest)) add('legacy-rule', '清理旧项目规则入口', [dest], () => fs.remove(dest))
       }
-      for (const name of ['AGENTS.md', 'CLAUDE.md']) {
-        const dest = path.join(projectDir, '.claude', name)
-        if (await fs.pathExists(dest)) {
-          const text = await fs.readFile(dest, 'utf8')
-          if (text.trim() === baseline.trim() || /<!-- DWY-BASELINE:START[\s\S]*?DWY-BASELINE:END -->/.test(text)) {
-            add('legacy-baseline', '清理旧项目基线托管内容', [dest], () => removeLegacyBaseline(baseline, dest))
-          }
-        }
-      }
     }
   }
   if (active.has('baseline')) {
-    const paths = { claude: path.join(homeDir, '.claude', 'CLAUDE.md'), codex: path.join(codexHome, 'AGENTS.md'), opencode: path.join(homeDir, '.config', 'opencode', 'AGENTS.md') }
-    for (const platform of cliPlatforms) {
-      const dest = paths[platform]
-      add('baseline', `更新 ${PLATFORM_LABELS[platform]} 全局通用规范（保留手写内容）`, [dest], () => syncGlobalBaselineDoc(baseline, dest))
-      platformState(platform).rules = []
+    const remove = contentActions.baseline === 'remove'
+    const providers = global ? [] : await baselineProviders(cliPlatforms, { homeDir, codexHome })
+    const inherited = providers.length > 0
+    const markProject = enabled => {
+      for (const platform of ['claude', 'codex', 'opencode']) {
+        if ((!global && platforms.includes(platform)) || nextProject.platforms[platform]) {
+          nextProject.platforms[platform] ||= { skills: [], rules: [], hooks: [], commands: [] }
+          nextProject.platforms[platform].baseline = enabled
+          if (global) projectChanged = true
+        }
+      }
     }
-    if (platforms.includes('claude')) {
-      const dest = path.join(homeDir, '.claude', 'AGENTS.md')
-      if (await fs.pathExists(dest)) {
-        const text = await fs.readFile(dest, 'utf8')
-        if (text.trim() === baseline.trim() || /<!-- DWY-BASELINE:START[\s\S]*?DWY-BASELINE:END -->/.test(text)) {
-          add('legacy-baseline', '清理旧全局基线托管内容', [dest], () => removeLegacyBaseline(baseline, dest))
+    const cleanBaseline = async (dest, boundary, label) => {
+      if (!await fs.pathExists(dest)) return false
+      const text = await fs.readFile(dest, 'utf8')
+      if (!await hasManagedBaseline(dest) && (!baseline.trim() || text.trim() !== baseline.trim())) return false
+      await addConfig('remove-baseline', label, [dest], boundary, () => text.trim() === baseline.trim()
+        ? removeLegacyBaseline(baseline, dest) : syncBaselineDoc('', dest))
+      return true
+    }
+    if (global) {
+      for (const platform of cliPlatforms) {
+        const dest = globalBaselinePath(platform, homeDir, codexHome)
+        if (remove) await cleanBaseline(dest, platform === 'codex' ? codexHome : homeDir, `移除 ${PLATFORM_LABELS[platform]} 全局通用规范（保留 Rules 和手写内容）`)
+        else await addConfig('baseline', `启用/更新 ${PLATFORM_LABELS[platform]} 全局通用规范（保留其他内容）`, [dest], platform === 'codex' ? codexHome : homeDir, () => syncBaselineDoc(baseline, dest))
+        platformState(platform).baseline = !remove
+      }
+      if (platforms.includes('claude')) await cleanBaseline(path.join(homeDir, '.claude', 'AGENTS.md'), homeDir, '清理旧全局基线托管内容')
+    } else {
+      const dest = path.join(projectDir, 'AGENTS.md')
+      if (remove || inherited) {
+        await cleanBaseline(dest, projectDir, inherited ? '全局已启用，清理项目重复基线' : '移除项目通用规范（保留 Rules 和手写内容）')
+        if (inherited) add('inherit', `通用规范使用全局：${providers.map(p => PLATFORM_LABELS[p]).join('、')}；项目禁止重复安装`,
+          providers.map(p => globalBaselinePath(p, homeDir, codexHome)), async () => {})
+      } else await addConfig('baseline', '启用/更新项目 AGENTS.md 通用规范（保留 Rules 和手写内容）', [dest], projectDir, () => syncBaselineDoc(baseline, dest))
+      markProject(!remove && !inherited)
+    }
+    if ((!global || !remove) && !isHome) {
+      if (global && await cleanBaseline(path.join(projectDir, 'AGENTS.md'), projectDir, '全局优先，清理当前项目重复基线')) markProject(false)
+      if (platforms.includes('claude')) {
+        for (const name of ['AGENTS.md', 'CLAUDE.md']) {
+          await cleanBaseline(path.join(projectDir, '.claude', name), projectDir, '清理旧项目基线托管内容')
         }
       }
     }
   }
   if (active.has('hooks')) {
     const manifests = await loadHookManifests(sourceDir)
+    const remove = contentActions.hooks === 'remove'
+    const removeHooks = async (platform, root, boundary, names, label) => {
+      const paths = []
+      for (const name of names) {
+        const dest = path.join(root, 'hooks', name)
+        if (await existsEntry(dest)) paths.push(dest)
+      }
+      if (await hasManagedHookConfig(platform, root, names)) paths.push(hookConfigFile(platform, root))
+      if (!paths.length) return false
+      await addConfig('remove-hooks', label, paths, boundary, () => removeManagedHooks(platform, root, names, paths))
+      return true
+    }
     for (const platform of platforms.filter(p => PLATFORM_SYNC_TYPES[p].includes('hooks'))) {
-      const hooks = scans.hooks.filter(hook => manifests.some(manifest => manifest.name === hook.name && (!manifest.platforms || manifest.platforms.includes(platform))))
+      const available = scans.hooks.filter(hook => manifests.some(manifest => manifest.name === hook.name && (!manifest.platforms || manifest.platforms.includes(platform))))
+      const provided = !global && !remove ? await globalHookNames({ platform, sourceDir, homeDir, codexHome }) : new Set()
+      const hooks = remove ? [] : available.filter(hook => !provided.has(hook.name))
       const root = global && platform === 'codex' ? codexHome : path.join(targetRoot, platform === 'claude' ? '.claude' : '.codex')
-      const paths = hooks.map(hook => path.join(root, 'hooks', hook.name))
-      const selectedNames = new Set(hooks.map(hook => hook.name))
-      const managedNames = new Set([...scans.hooks.map(hook => hook.name), ...approved(platform, 'hooks')])
-      const removedNames = []
-      const hookDir = path.join(root, 'hooks')
-      if (await fs.pathExists(hookDir)) {
-        for (const name of await fs.readdir(hookDir)) {
-          if (managedNames.has(name) && !selectedNames.has(name)) {
-            paths.push(path.join(hookDir, name))
-            removedNames.push(name)
+      const boundary = global && platform === 'codex' ? codexHome : targetRoot
+      const historical = (targetState.platforms[platform]?.hooks || []).filter(safeName)
+      const allManaged = new Set([...scans.hooks.map(hook => hook.name), ...(remove ? historical : []), ...approved(platform, 'hooks')])
+      if (remove || hooks.length === 0) {
+        await removeHooks(platform, root, boundary, allManaged, `${remove ? '移除' : '全局已启用，清理重复'} ${PLATFORM_LABELS[platform]} ${global ? '全局' : '项目'} 托管 Hooks`)
+      } else {
+        await assertHooksEnabled(platform, root)
+        const paths = hooks.map(hook => path.join(root, 'hooks', hook.name))
+        const selectedNames = new Set(hooks.map(hook => hook.name))
+        const removedNames = []
+        const hookDir = path.join(root, 'hooks')
+        if (await fs.pathExists(hookDir)) {
+          for (const name of await fs.readdir(hookDir)) {
+            if (allManaged.has(name) && !selectedNames.has(name)) {
+              paths.push(path.join(hookDir, name))
+              removedNames.push(name)
+            }
           }
         }
+        paths.push(hookConfigFile(platform, root))
+        const sync = platform === 'claude' ? syncClaude : syncCodex
+        const cleanup = removedNames.length ? `；清理旧托管脚本：${removedNames.join('、')}` : ''
+        await addConfig('hooks', `同步 ${PLATFORM_LABELS[platform]} ${global ? '全局' : '项目'} Hooks${cleanup}`, paths, boundary,
+          () => sync({ sourceDir, projectDir: targetRoot, global, homeDir, codexHome, selected: { skills: [], hooks }, syncTypes: ['hooks'], staleRemovals: staleRemovals[platform] }))
+      }
+      if (provided.size) add('inherit', `${PLATFORM_LABELS[platform]} Hooks 使用全局：${[...provided].join('、')}；项目不重复安装`, [], async () => {})
+      platformState(platform).hooks = remove ? [] : [...new Set([...hooks.map(hook => hook.name), ...retained(platform, 'hooks')])].sort()
+      if (global && !remove && !isHome) {
+        const local = path.join(projectDir, platform === 'claude' ? '.claude' : '.codex')
+        const duplicates = new Set(available.map(hook => hook.name))
+        if (await removeHooks(platform, local, projectDir, duplicates, `全局优先，清理当前项目 ${PLATFORM_LABELS[platform]} 重复 Hooks`)
+          && nextProject.platforms[platform]) {
+          nextProject.platforms[platform].hooks = (nextProject.platforms[platform].hooks || []).filter(name => !duplicates.has(name))
+          projectChanged = true
+        }
       }
-      paths.push(path.join(root, platform === 'claude' ? 'settings.json' : 'hooks.json'))
-      const sync = platform === 'claude' ? syncClaude : syncCodex
-      const cleanup = removedNames.length ? `；清理旧托管脚本：${removedNames.join('、')}` : ''
-      add('hooks', `同步 ${PLATFORM_LABELS[platform]} ${global ? '全局' : '项目'} Hooks${cleanup}`, paths,
-        () => sync({ sourceDir, projectDir: targetRoot, global, homeDir, codexHome, selected: { skills: [], hooks }, syncTypes: ['hooks'], staleRemovals: staleRemovals[platform] }))
-      platformState(platform).hooks = [...new Set([...hooks.map(hook => hook.name), ...retained(platform, 'hooks')])].sort()
     }
   }
   return { operations, nextProject, nextGlobal, projectChanged, globalChanged: global && contentTypes.length > 0 }

package/src/sync.js

@@ -290,7 +290,8 @@ async function removeUnselected(typePlural, existingNames, selectedNames, templa
   return count
 }
 
-function buildClaudeHooksSettings(manifests, selectedHookNames, global) {
+/** 生成 Claude Hook 注册，继承检测和写入共用相同命令格式。 */
+export function buildClaudeHooksSettings(manifests, selectedHookNames, global) {
   const grouped = new Map()
 
   for (const manifest of manifests) {
@@ -320,13 +321,18 @@ function buildClaudeHooksSettings(manifests, selectedHookNames, global) {
   return settings
 }
 
-function isManagedClaudeHookCommand(command, managedHookNames) {
+/** 仅识别完整的 dwy 生成命令，避免误删提到同名路径的个人命令。 */
+export function isManagedClaudeHookCommand(command, managedHookNames) {
   if (typeof command !== 'string') return false
-  const match = command.match(/\.claude\/hooks\/([^\s'"]+)/)
-  return !!(match && managedHookNames.has(match[1]))
+  return [...managedHookNames].some(name => [
+    `bash "$HOME/.claude/hooks/${name}"`,
+    `bash "$CLAUDE_PROJECT_DIR/.claude/hooks/${name}"`,
+    `bash ~/.claude/hooks/${name}`,
+  ].includes(command))
 }
 
-function mergeClaudeHooks(existingHooks, generatedHooks, managedHookNames) {
+/** 替换指定托管 Hook 注册，保留其他命令及配置字段。 */
+export function mergeClaudeHooks(existingHooks, generatedHooks, managedHookNames) {
   const merged = {}
   const sourceEvents = new Set([
     ...Object.keys(existingHooks || {}),
@@ -348,14 +354,12 @@ function mergeClaudeHooks(existingHooks, generatedHooks, managedHookNames) {
   return Object.keys(merged).length > 0 ? merged : undefined
 }
 
-async function syncSettings(sourceDir, targetDir, selectedHookNames, global) {
+async function syncSettings(sourceDir, targetDir, selectedHookNames, global, staleHookNames) {
   const settingsDest = path.join(targetDir, 'settings.json')
   const manifests = await loadHookManifests(sourceDir)
   const generatedSettings = buildClaudeHooksSettings(manifests, selectedHookNames, global)
   const managedHookNames = new Set(
-    manifests
-      .filter(manifest => !manifest.platforms || manifest.platforms.includes('claude'))
-      .map(manifest => manifest.name),
+    [...manifests.map(manifest => manifest.name), ...staleHookNames],
   )
 
   let merged
@@ -470,7 +474,7 @@ export async function syncClaude({
     syncedCount += await copyItems(skills, projectTargetDir)
   }
   if (syncTypes.includes('hooks')) {
-    syncedCount += await syncSettings(sourceDir, projectTargetDir, selectedHookNames, global)
+    syncedCount += await syncSettings(sourceDir, projectTargetDir, selectedHookNames, global, approvedStaleHooks)
     syncedCount += await copyHooks(syncedSelection.hooks, projectTargetDir)
   }