create-dwy 0.23.0 → 0.25.0

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # create-dwy
 
+## [0.25.0] - 2026-11-06
+
+### Minor Changes
+
+- 同步流程简化为「范围 → Skills → 项目 Rules → 通用规范 → Hooks → CLI → 预览确认」。规范和 Hooks 默认启用；Codex 默认选中，并恢复当前范围已同步的其他 CLI。项目已有有效全局规范或完整 Hooks 时跳过对应选择，不重复安装。
+- 模板从公开源码仓库 master 分支运行时获取，新增 Skills 无需再发布 CLI。使用增量 Git 对象缓存和验证后的模板快照；离线保留有效缓存，无缓存才回退随包模板。首次下载显示进度，异常退出后的锁可自动恢复。
+- 确认后刷新当前范围所需的共享 Skills，项目补其他 CLI 入口时保留有效全局同名共享内容；执行后报告实际完成信息。保留旧脚本的显式同步范围、个人配置及取消前目标不写入的约束。
+- 新增版本克制与想法收录 Skill，支持新增功能分析、阶段收敛、持久化想法清单和新版本规划提醒。
+- 修复无同步记录的旧 Cursor Rules 默认选择恢复，补充全局继承、内容保护、增量更新、离线及多进程锁回归，并更新同步帮助与使用说明。
+
+---
+
+## [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.25.0",
   "description": "项目脚手架与多平台 AI 配置同步工具",
   "type": "module",
   "bin": {

package/src/cli-help.js

@@ -14,36 +14,39 @@ export function buildHelpText(version) {
     `dwy ${version}`,
     '',
     '用法：',
-    '  dwy            选择范围、平台和处理内容，预览清单后同步',
+    '  dwy            选择范围、配置和 CLI，预览清单后同步',
     '  dwy sync       同上',
     '  dwy upgrade    升级到 npm 最新正式版，并刷新共享 Skills',
-    '  dwy refresh    用当前 CLI 模板刷新已安装的共享 Skills',
+    '  dwy refresh    用最新模板刷新已安装的共享 Skills，无需升级 CLI',
     '  dwy migrate    一键迁移老项目已有的托管 Skills，原目录先备份',
     '  dwy --help     显示本说明',
     '  dwy --version  显示版本',
     '',
     '同步步骤：',
     '  1. 选择同步范围：当前项目或全局。',
-    '  2. 选择该范围支持的平台；全局不提供 Cursor。',
-    '  3. 选择本次处理内容，默认只选 Skills；未选择的类型保持原样。',
-    '     项目：Skills、项目 Rules、Hooks；全局：Skills、全局通用规范、Hooks。',
-    '     内容选项按平台能力过滤。Hooks 选中类型后按平台自动处理。',
-    '  4. 逐项选择 Skills / 项目 Rules；全局通用规范显示摘要。',
-    '  5. 查看写入、备份和清理清单，确认后执行；取消不写文件。',
+    '  2. 选择 Skills。',
+    '  3. 仅项目范围选择 Rules；全局跳过。',
+    '  4. 选择 AGENTS.md 通用规范，默认启用。',
+    '  5. 选择 Hooks，默认启用。',
+    '     项目已有有效全局规范或全部所需全局 Hooks 时，跳过对应操作页。',
+    '  6. 最后选择 CLI；首次只选 Codex，后续恢复当前范围同步过的 CLI 与有效旧托管入口。',
+    '  7. 按最终 CLI 重新核算覆盖，预览实际写入、迁移、备份和清理清单。',
+    '  8. 确认后执行，显示实际完成信息；取消不改同步目标。',
     '  Commands 不参与同步。',
     '',
     '交互按键：',
     '  Skills / Rules：←/→ 切分类，↑/↓ 移动，Space 勾选，a 全选／清空当前分类。',
-    '  范围 / 平台 / 内容：↑/↓ 移动；多选用 Space 勾选，可输入关键字筛选。',
+    '  范围 / 通用规范 / Hooks / CLI：↑/↓ 移动；CLI 用 Space 勾选，可输入关键字筛选。',
     '  Enter 确认当前步骤，Esc 或 Ctrl+C 取消。',
     '',
     '常见用法：',
-    '  同步当前项目：cd your-project 后执行 dwy，选择「当前项目」及本次处理内容。',
-    '  同步全局：执行 dwy，选择「全局」及 Skills、全局通用规范或 Hooks。',
+    '  同步当前项目：cd your-project 后执行 dwy，选择「当前项目」。',
+    '  同步全局：执行 dwy，选择「全局」。',
+    '  移除配置：在当前范围取消 Skills / Rules 勾选，或关闭 Hooks / 通用规范，再确认。',
     '  更新或调整配置：再次执行 dwy sync，检查勾选项，再确认同步。',
     '  更新 CLI：dwy upgrade（全局安装时可用；更新后执行 dwy --version 查看版本）。',
     '  迁移老项目：cd your-project 后执行 dwy migrate，无需重新勾选。',
-    '  手动升级包后：执行一次 dwy refresh，所有已迁移的链接同时生效。',
+    '  只更新 Skills：执行 dwy refresh，所有已迁移的链接同时生效。',
     '  首次安装：npm install -g create-dwy@latest',
     '',
     '平台支持：',
@@ -52,18 +55,32 @@ export function buildHelpText(version) {
     '  OpenCode：全局 ~/.config/opencode/AGENTS.md；项目根 AGENTS.md；当前不支持 Hooks。',
     '  Cursor：仅项目 Rules；全局规则在 Cursor 设置中管理。',
     '',
-    '同步仅处理当前范围、所选平台和内容；未选择的类型及其记录保持原样。',
+    '同步按当前范围和最终 CLI 执行；项目 AGENTS.md 由多个 CLI 共享。',
     '用户主目录不能作为项目范围同步，请选择全局或进入项目目录。',
-    '取消已有勾选会在确认后移除当前范围的托管入口；不勾选整个类型则不处理。',
+    '关闭选项只移除当前范围托管内容；项目操作不移除全局配置。',
     'Skills 副本集中在 ~/.dwy/skills；项目和全局使用目录链接，同平台全局入口优先。',
     '项目 Skills 全部适用平台均有全局入口时显示「全局已启用」，不能重复勾选。',
     '部分平台已有全局入口时仍可选，只为缺少全局入口的平台安装项目链接。',
-    '项目同步只清理项目重复入口，不改全局提供者；真实目录先备份。',
-    'sync / migrate 仅准备缺失或损坏副本，不刷新已有共享内容；refresh / upgrade 才刷新。',
+    'Hooks 与 Skills 独立；整组管理，项目仅安装缺少有效全局注册的 Hooks。',
+    '全局 Hook 的脚本与对应事件、matcher、完整命令注册均有效时，项目禁止重复安装。',
+    '任一适用 CLI 已有 dwy 全局通用规范时，项目继承并清理重复基线；最终 CLI 中缺失的全局规范需补齐。',
+    '手写 AGENTS.md 本身不算全局已安装；通用规范与 Rules 共用文件但独立管理。',
+    '移除通用规范仅删除基线块；项目 Rules 独立管理，保留手写内容。',
+    '全局启用会明确列出当前项目重复项清理；全局移除不会自动向项目补装。',
+    '项目同步只清理项目重复入口，不改写有效全局提供者；真实目录先备份。',
+    '确认前仅可更新模板缓存；确认后才改项目／全局配置，并刷新所选共享 Skills。',
+    '由有效全局入口提供的 Skills 不借项目同步改写；全部已安装副本用 dwy refresh 更新。',
+    'sync / migrate 脚本接口仍须显式指定范围。',
     '产品流程缺失的外部依赖也列入清单，确认后联网补齐，已有内容保留。',
     '旧真实目录备份到同步根的 .dwy/skill-backups；个人 Skills、Rules、Hooks 不参与 migrate。',
     '旧项目首次需执行 dwy migrate；迁移后无需逐项目刷新 Skills。',
     'Rules / Hooks 的模板更新仍需执行 dwy sync；已有会话缓存的 Skill 可能需要重新加载。',
     '',
+    '模板更新：',
+    '  固定公开仓库 https://github.com/danweiyuancircle/dwy-ai-experience.git 的 master 分支 dwy-cli/templates/ai-tools。',
+    '  DWY_TEMPLATE_SOURCE_DIR 开发覆盖优先；远端模板缓存在 ~/.dwy/template-source。',
+    '  未变更只检查 commit；离线保留有效缓存，无有效缓存时回退包内模板并提示。',
+    '  新增 Skills 只需更新模板分发分支，无需发布 CLI；dwy upgrade 更新程序。',
+    '',
   ].join('\n')
 }

package/src/skill-store.js

@@ -36,7 +36,7 @@ export async function ensureSharedSkills({ skills, homeDir = os.homedir() }) {
 }
 
 /**
- * 将包内 Skills 准备到稳定用户目录，返回指向共享副本的条目。
+ * 将当前模板 Skills 准备到稳定用户目录，返回指向共享副本的条目。
  * 同一用户的刷新互斥；完整副本准备失败时不替换旧内容。外部 Skills 缓存不纳入本模块清单。
  */
 export async function prepareSharedSkills({ skills, homeDir = os.homedir() }) {
@@ -183,15 +183,15 @@ export async function linkSkill({ skill, dest, backupRoot }) {
   }
 }
 
-/** 使用当前 CLI 包内模板刷新已有共享副本；新包移除的条目保留，避免其他项目坏链。 */
+/** 从最新可用模板刷新已有共享副本；模板移除的条目保留，避免其他项目坏链。 */
 export async function refreshSharedSkills({ sourceDir, homeDir = os.homedir() } = {}) {
   const names = await readInstalledNames(homeDir)
-  const scans = await scanSkills(sourceDir || await resolveSourceDir())
+  const scans = await scanSkills(sourceDir || await resolveSourceDir({ homeDir }))
   const available = new Map(scans.map(skill => [skill.name, skill]))
   const updated = names.filter(name => available.has(name))
   const retained = names.filter(name => !available.has(name))
   await prepareSharedSkills({ skills: updated.map(name => available.get(name)), homeDir })
-  for (const name of retained) console.log(chalk.yellow(`当前 CLI 已移除 ${name}，保留共享旧副本以免其他项目链接失效。`))
+  for (const name of retained) console.log(chalk.yellow(`当前模板已移除 ${name}，保留共享旧副本以免其他项目链接失效。`))
   console.log(chalk.green(`已刷新 ${updated.length} 个共享 Skills，保留 ${retained.length} 个旧副本。`))
   return { updated, retained }
 }

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 { parseManagedRuleNames, scanExistingCodexHooks, scanExistingCodexSkills } from './sync-codex.js'
+import { interactiveSelect, loadHookManifests, readBaselineDoc, resolveSourceDir, scanExisting, scanHooks, scanRules, scanSkills } from './sync.js'
+import { hasManagedBaseline, 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, globalBaselinePath, globalHookNames, hasManagedHookConfig } from './sync-inheritance.js'
 
 const PLATFORM_OPTIONS = [
   { value: 'claude', label: 'Claude Code', description: '支持 Skills、项目 Rules、Hooks 和全局通用规范' },
@@ -58,25 +59,44 @@ export function buildSelectionDefaultsFromSyncState(existing, syncState, platfor
   return Object.values(result).some(names => names.size) ? result : existing
 }
 
-/** 从当前范围的实际入口推导平台默认值；不读取另一个范围的配置。 */
+/** Codex 默认选中；恢复当前范围的同步记录和有效旧托管入口，空目录不算已同步。 */
 export async function buildPlatformDefaultsFromLocalState(projectDir, scope = 'project', codexHome = path.join(projectDir, '.codex')) {
-  const defaults = []
-  if (await fs.pathExists(path.join(projectDir, '.claude'))) defaults.push('claude')
-  if (await fs.pathExists(path.join(projectDir, '.codex'))
-    || (scope === 'global' && await fs.pathExists(codexHome))
-    || await fs.pathExists(path.join(projectDir, '.agents'))
-    || (scope === 'project' && await fs.pathExists(path.join(projectDir, 'AGENTS.md')))) defaults.push('codex')
-  if (scope === 'project' && await fs.pathExists(path.join(projectDir, '.cursor'))) defaults.push('cursor')
-  if (await fs.pathExists(path.join(projectDir, ...(scope === 'global' ? ['.config', 'opencode'] : ['.opencode'])))) defaults.push('opencode')
-  return defaults.length ? defaults : ['claude', 'codex']
+  const defaults = ['codex']
+  const state = await loadSyncState(projectDir)
+  for (const platform of ['claude', 'opencode', ...(scope === 'project' ? ['cursor'] : [])]) {
+    const root = scope === 'global' ? resolveGlobalSkillDir(platform, projectDir)
+      : resolveProjectSkillDir(projectDir, platform)
+    let managed = Boolean(state.platforms[platform])
+    if (root && await fs.pathExists(root)) {
+      for (const name of await fs.readdir(root)) {
+        if (name.startsWith('dwy-') && await fs.pathExists(path.join(root, name, 'SKILL.md'))) managed = true
+      }
+    }
+    if (platform === 'cursor') {
+      if ([...await scanExistingCursorRules(projectDir)].some(name => name.startsWith('dwy-') || name === '00-dwy-global.mdc')) managed = true
+    } else {
+      const baseline = scope === 'global' ? globalBaselinePath(platform, projectDir, codexHome)
+        : path.join(projectDir, platform === 'claude' ? '.claude' : '.opencode', 'AGENTS.md')
+      if (await hasManagedBaseline(baseline)) managed = true
+      if (platform === 'claude') {
+        const configRoot = path.join(projectDir, '.claude')
+        if (await hasManagedBaseline(path.join(configRoot, 'CLAUDE.md'))
+          || await hasManagedHookConfig(platform, configRoot, await scanExisting(configRoot, 'hooks'))) managed = true
+      }
+    }
+    if (managed) defaults.push(platform)
+  }
+  return defaults
 }
 
-async function selectPlatforms(root, scope, codexHome) {
+async function selectPlatforms(root, scope, initialValues) {
+  const state = await loadSyncState(root)
   const result = await searchableMultiselect({
     message: '选择要同步的平台',
     options: PLATFORM_OPTIONS.filter(option => scope === 'project' || option.value !== 'cursor')
-      .map(option => ({ ...option, description: contentOptions(scope, [option.value]).map(item => item.label).join('、') })),
-    initialValues: await buildPlatformDefaultsFromLocalState(root, scope, codexHome),
+      .map(option => ({ ...option, description: [state.platforms[option.value] ? '已有同步记录，将核对并修复本地配置' : '',
+        contentOptions(scope, [option.value]).map(item => item.label).join('、')].filter(Boolean).join('；') })),
+    initialValues,
     required: true, maxItems: 6, placeholder: SEARCH_PLACEHOLDER,
   })
   return isCancel(result) ? null : result
@@ -126,7 +146,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))
     }
@@ -139,7 +159,7 @@ function normalizeRemovals(raw) {
     Object.fromEntries(Object.entries(types).map(([type, names]) => [type, new Set(names)]))]))
 }
 
-/** `dwy` 和 `dwy sync` 共用范围 → 平台 → 内容 → 逐项选择 → 清单确认。 */
+/** `dwy` 和 `dwy sync` 共用范围 → Skills → 项目 Rules → 规范 → Hooks → CLI → 确认。 */
 export async function runDwy(opts = {}) {
   console.log(chalk.bold.cyan('\ndwy') + chalk.gray(' · AI 开发工具\n'))
   const action = normalizeAction(opts.action)
@@ -165,7 +185,7 @@ export async function migrateSkills({
   if (await fs.pathExists(homeDir) && realProject === await fs.realpath(homeDir)) {
     throw new Error('当前目录是用户主目录，请使用全局同步或进入项目目录迁移')
   }
-  const scans = await scanSkills(sourceDir || await resolveSourceDir())
+  const scans = await scanSkills(sourceDir || await resolveSourceDir({ homeDir }))
   const available = new Map(scans.map(skill => [skill.name, skill]))
   const state = await loadSyncState(projectDir)
   const existingByPlatform = {}
@@ -213,65 +233,107 @@ export async function migrateSkills({
 
 /**
  * 只执行点名范围和内容；测试/脚本可注入选择，确认前只读。
- * contentTypes 未传时，已有脚本按 selected 中明确提供的字段处理；主交互默认只选 Skills。
+ * 主交互按内容顺序收集选择，CLI 后选，执行前重新核算继承；显式脚本仅处理点名的类型。
  */
 export async function syncAll({
   sourceDir: sourceDirOverride, projectDir: projectDirOverride, selected: selectedOverride,
   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()
+  const sourceDir = sourceDirOverride || await resolveSourceDir({ homeDir })
   if (!await fs.pathExists(sourceDir)) throw new Error('ai-tools templates not found in repo')
   const projectDir = projectDirOverride || process.cwd()
   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 }
   if (!['project', 'global'].includes(scope)) throw new Error('无效同步范围')
   const global = scope === 'global', targetRoot = global ? homeDir : projectDir
-  const platforms = platformsOverride || await selectPlatforms(targetRoot, scope, codexHome)
-  if (platforms === null) { console.log(chalk.yellow('已取消同步。')); return }
+  let platforms = platformsOverride || await buildPlatformDefaultsFromLocalState(targetRoot, scope, codexHome)
   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
+  const scans = { skills: await scanSkills(sourceDir), rules: await scanRules(sourceDir), hooks: await scanHooks(sourceDir), commands: [] }
+  const mainFlow = !typesOverride && !selectedOverride && modeOverride !== SYNC_MODE_SKILLS
+  const availablePlatforms = PLATFORM_OPTIONS.filter(option => !global || option.value !== 'cursor').map(option => option.value)
+  const allowed = new Set(contentOptions(scope, mainFlow ? availablePlatforms : platforms).map(option => option.value))
   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,
-    })
-    if (isCancel(result)) { console.log(chalk.yellow('已取消同步。')); return }
-    contentTypes = result
+    contentTypes = [...allowed]
+    if (!await fs.pathExists(path.join(sourceDir, 'AGENTS.md'))) contentTypes = contentTypes.filter(type => type !== 'baseline')
+    if (!scans.hooks.length) contentTypes = contentTypes.filter(type => type !== 'hooks')
   }
   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 cursorRules = new Set(scans.rules.filter(rule => existing.cursor.rules.has(buildCursorRuleName(rule.name))).map(rule => rule.name))
   const current = Object.fromEntries(['skills', 'rules', 'hooks'].map(type => [type,
-    unionSets(...platforms.map(platform => existing[platform][type]))]))
+    unionSets(...platforms.map(platform => platform === 'cursor' && type === 'rules' ? cursorRules : existing[platform][type]))]))
   const defaults = buildSelectionDefaultsFromSyncState(current, targetState, platforms)
   for (const type of ['skills', 'rules', 'hooks']) defaults[type] = unionSets(defaults[type], current[type])
-  const choices = !global && contentTypes.includes('skills')
+  // CLI 尚未选择时允许勾选所有 Skills；最终计划按实际 CLI 去重，避免提前禁用其他 CLI 所需条目。
+  const choices = platformsOverride && !global && contentTypes.includes('skills')
     ? { ...scans, skills: await projectSkillChoices(scans.skills, platforms, { homeDir, codexHome }) } : scans
   const selected = selectedOverride
     ? { 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 ['baseline', 'hooks'].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 通用规范'
+      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
+        }
+        inheritedHooks = total > 0 && covered === total
+      }
+      if (inherited.length || inheritedHooks) {
+        contentActions[type] = 'sync'
+        continue
+      }
+      const action = await searchableSelect({
+        message: `选择 ${name} 操作`, initialValue: 'sync',
+        options: [
+          { value: 'sync', label: '启用 / 更新',
+            description: type === 'hooks' && !global ? '只为缺少有效全局注册的 Hook 安装项目配置，其他仅去重' : '执行清单会列出实际路径及清理项' },
+          { value: 'remove', label: `移除当前范围的${name}`, description: '只移除 dwy 托管内容，保留个人配置和其他类型' },
+        ],
+      })
+      if (isCancel(action)) { console.log(chalk.yellow('已取消同步。')); return }
+      contentActions[type] = action
+    }
+  }
+  if (!platformsOverride) {
+    platforms = await selectPlatforms(targetRoot, scope, platforms)
+    if (platforms === null) { console.log(chalk.yellow('已取消同步。')); return }
+  }
+  const options = contentOptions(scope, platforms)
+  if (mainFlow) contentTypes = contentTypes.filter(type => options.some(option => option.value === type))
   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,
+    refreshSkills: mainFlow,
     skillScope: normalizeSkillScope(skillScopeOverride),
   })
   const nextTarget = global ? plan.nextGlobal : plan.nextProject
@@ -279,16 +341,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}`)
@@ -297,7 +364,10 @@ export async function syncAll({
     const answer = confirmed === false ? false : await confirm({ message: '确认同步？' })
     if (isCancel(answer) || !answer) { console.log(chalk.yellow('已取消同步。')); return }
   }
-  for (const operation of plan.operations) await operation.run()
+  for (const operation of plan.operations) {
+    await operation.run()
+    if (!['state', 'inherit'].includes(operation.kind)) console.log(chalk.green(`已完成：${operation.label}`))
+  }
   console.log(chalk.green('同步完成。'))
   return plan.operations.map(({ kind, label, paths }) => ({ kind, label, paths }))
 }

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
@@ -362,7 +377,7 @@ export async function syncCodex({
   syncTypes = ['skills', 'hooks'],
   staleRemovals = {},
 } = {}) {
-  const sourceDir = sourceDirOverride || await resolveSourceDir()
+  const sourceDir = sourceDirOverride || await resolveSourceDir({ homeDir })
   if (!await fs.pathExists(sourceDir)) {
     throw new Error('ai-tools templates not found in repo')
   }
@@ -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-cursor.js

@@ -108,10 +108,11 @@ export async function scanExistingCursorRules(projectDir) {
 export async function syncCursor({
   sourceDir: sourceDirOverride,
   projectDir,
+  homeDir,
   selected,
   staleRemovals = {},
 } = {}) {
-  const sourceDir = sourceDirOverride || await resolveSourceDir()
+  const sourceDir = sourceDirOverride || await resolveSourceDir({ homeDir })
   if (!await fs.pathExists(sourceDir)) {
     throw new Error('ai-tools templates not found in repo')
   }