create-dwy 0.24.1 → 0.25.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # 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

package/package.json

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

package/src/cli-help.js

@@ -14,37 +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 和通用规范。',
-    '     项目：Skills、Hooks、Rules、AGENTS.md 通用规范；全局：Skills、Hooks、AGENTS.md 通用规范。',
-    '     内容按平台能力过滤；未选择的类型保持原样。',
-    '  4. 逐项选择 Skills / Rules；Hooks 和通用规范分别选择启用/更新或移除。',
-    '  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 或 AGENTS.md 通用规范。',
-    '  移除配置：选择对应范围和 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',
     '',
     '平台支持：',
@@ -53,24 +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 全部适用平台均有全局入口时显示「全局已启用」，不能重复勾选。',
     '部分平台已有全局入口时仍可选，只为缺少全局入口的平台安装项目链接。',
     'Hooks 与 Skills 独立；整组管理，项目仅安装缺少有效全局注册的 Hooks。',
     '全局 Hook 的脚本与对应事件、matcher、完整命令注册均有效时，项目禁止重复安装。',
-    '任一所选 CLI 已有 dwy 全局通用规范时，项目只能继承并清理重复基线；其他 CLI 需补齐全局规范。',
+    '任一适用 CLI 已有 dwy 全局通用规范时，项目继承并清理重复基线；最终 CLI 中缺失的全局规范需补齐。',
     '手写 AGENTS.md 本身不算全局已安装；通用规范与 Rules 共用文件但独立管理。',
-    '移除通用规范仅删除基线块，保留 Rules 和手写内容；移除后不会因默认值自动重新启用。',
+    '移除通用规范仅删除基线块；项目 Rules 独立管理，保留手写内容。',
     '全局启用会明确列出当前项目重复项清理；全局移除不会自动向项目补装。',
-    '项目同步只清理项目重复入口，不改全局提供者；真实目录先备份。',
-    'sync / migrate 仅准备缺失或损坏副本，不刷新已有共享内容；refresh / upgrade 才刷新。',
+    '项目同步只清理项目重复入口，不改写有效全局提供者；真实目录先备份。',
+    '确认前仅可更新模板缓存；确认后才改项目／全局配置，并刷新所选共享 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

@@ -7,12 +7,12 @@ import { normalizeSkillScope, resolveProjectSkillDir, resolveGlobalSkillDir, cop
 import { ensureSharedSkills } from './skill-store.js'
 import { chalk } from './utils.js'
 import { interactiveSelect, loadHookManifests, readBaselineDoc, resolveSourceDir, scanExisting, scanHooks, scanRules, scanSkills } from './sync.js'
-import { parseManagedRuleNames, scanExistingCodexHooks, scanExistingCodexSkills } from './sync-codex.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, globalHookNames } from './sync-inheritance.js'
+import { assertConfigPath, baselineProviders, globalBaselinePath, globalHookNames, hasManagedHookConfig } from './sync-inheritance.js'
 
 const PLATFORM_OPTIONS = [
   { value: 'claude', label: 'Claude Code', description: '支持 Skills、项目 Rules、Hooks 和全局通用规范' },
@@ -59,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
@@ -135,20 +154,12 @@ 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)]))]))
 }
 
-/** `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)
@@ -174,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 = {}
@@ -222,7 +233,7 @@ export async function migrateSkills({
 
 /**
  * 只执行点名范围和内容；测试/脚本可注入选择，确认前只读。
- * contentTypes 未传时，已有脚本按 selected 中明确提供的字段处理；主交互默认只选 Skills。
+ * 主交互按内容顺序收集选择，CLI 后选，执行前重新核算继承；显式脚本仅处理点名的类型。
  */
 export async function syncAll({
   sourceDir: sourceDirOverride, projectDir: projectDirOverride, selected: selectedOverride,
@@ -231,7 +242,7 @@ export async function syncAll({
   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({
@@ -244,33 +255,32 @@ export async function syncAll({
   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: defaultContentTypes(scope, platforms, targetState), 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 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: [] }
@@ -278,11 +288,10 @@ export async function syncAll({
   if (selected === null) { console.log(chalk.yellow('已取消同步。')); return }
   const contentActions = { ...actionsOverride }
   if (!selectedOverride) {
-    for (const type of ['hooks', 'baseline'].filter(type => contentTypes.includes(type))) {
+    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 通用规范'
-      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)
@@ -292,14 +301,17 @@ export async function syncAll({
           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
       }
+      if (inherited.length || inheritedHooks) {
+        contentActions[type] = 'sync'
+        continue
+      }
       const action = await searchableSelect({
         message: `选择 ${name} 操作`, initialValue: 'sync',
         options: [
-          { value: 'sync', label: inherited.length ? '使用全局，仅清理项目重复基线' : inheritedHooks ? '使用全局，仅清理项目重复 Hooks' : '启用 / 更新',
+          { value: 'sync', label: '启用 / 更新',
             description: type === 'hooks' && !global ? '只为缺少有效全局注册的 Hook 安装项目配置，其他仅去重' : '执行清单会列出实际路径及清理项' },
           { value: 'remove', label: `移除当前范围的${name}`, description: '只移除 dwy 托管内容，保留个人配置和其他类型' },
         ],
@@ -308,6 +320,12 @@ export async function syncAll({
       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) : ''
@@ -315,6 +333,7 @@ export async function syncAll({
     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
@@ -345,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

@@ -377,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')
   }

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')
   }

package/src/sync-opencode.js

@@ -48,7 +48,7 @@ export async function syncOpenCode({
   sharedSkills,
   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')
   }

package/src/sync-plan.js

@@ -1,6 +1,6 @@
 import fs from 'fs-extra'
 import path from 'node:path'
-import { ensureSharedSkills, linkSkill, removeSkillEntry } from './skill-store.js'
+import { ensureSharedSkills, prepareSharedSkills, linkSkill, removeSkillEntry } from './skill-store.js'
 import { findGlobalSkill, globalSkillRoots, resolveGlobalSkillDir, resolveProjectSkillDir } from './sync-global-skills.js'
 import { loadHookManifests, syncClaude } from './sync.js'
 import { hasManagedBaseline, removeLegacyBaseline, syncBaselineDoc, syncCodex, syncProjectAgentsMd } from './sync-codex.js'
@@ -69,12 +69,13 @@ function ownedGlobalRoots(platform, homeDir, codexHome) {
 
 /**
  * 只读计算本次全部操作和下一份状态；run 回调只在确认后执行。
- * Skills 的入口与内容刷新分离；项目去重只删除项目入口，不改写全局提供者。
+ * 主交互可在确认后刷新所选共享内容；显式脚本默认仅补缺，项目去重不改写全局提供者。
  */
 export async function buildSyncPlan({
   scope, platforms, contentTypes, selected, scans, sourceDir, projectDir, homeDir, codexHome,
   projectState, globalState, staleRemovals = {}, staleEntries = {}, baseline,
   contentActions = {},
+  refreshSkills = false,
   skillScope = { destinations: ['project'], globalSkills: [] },
 }) {
   const global = scope === 'global'
@@ -196,9 +197,25 @@ export async function buildSyncPlan({
     }
     if (neededSkills.size) {
       const skills = [...neededSkills.values()]
-      operations.unshift({ kind: 'ensure-skills', label: '准备缺失的共享副本；已有内容不刷新',
+      const preserved = []
+      if (refreshSkills && !global) {
+        for (let i = 0; i < skills.length; i++) {
+          const skill = skills[i], shared = path.join(homeDir, '.dwy', 'skills', skill.name)
+          if (!await validSkill(shared)) continue
+          for (const platform of ['claude', 'codex', 'opencode']) {
+            if (!await findGlobalSkill({ name: skill.name, platform, homeDir, codexHome })) continue
+            // 补项目入口不能间接刷新其他 CLI 正在使用的全局共享副本。
+            skills[i] = { ...skill, sourcePath: shared }
+            preserved.push(skill.name)
+            break
+          }
+        }
+      }
+      const label = refreshSkills ? `更新所选共享 Skills（所有同名链接生效）${preserved.length ? `；保留全局共享内容：${preserved.join('、')}` : ''}`
+        : '准备缺失的共享副本；已有内容不刷新'
+      operations.unshift({ kind: 'ensure-skills', label,
         paths: [...skills.map(skill => path.join(homeDir, '.dwy', 'skills', skill.name)), path.join(homeDir, '.dwy', 'skill-store.json')],
-        run: () => ensureSharedSkills({ skills, homeDir }) })
+        run: () => (refreshSkills ? prepareSharedSkills : ensureSharedSkills)({ skills, homeDir }) })
     }
     if ([...neededSkills.values()].some(skill => skill.category === '产品0到1')) {
       const target = path.join(process.env.DWY_HOME || path.join(homeDir, '.dwy'), 'skills')
@@ -272,7 +289,8 @@ export async function buildSyncPlan({
       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('、')}；项目禁止重复安装`,
+        const missing = cliPlatforms.filter(platform => !providers.includes(platform))
+        if (inherited) add('inherit', `通用规范使用全局：${providers.map(p => PLATFORM_LABELS[p]).join('、')}；项目禁止重复安装${missing.length ? `；${missing.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)

package/src/sync.js

@@ -2,8 +2,9 @@ import fs from 'fs-extra'
 import path from 'path'
 import { isCancel } from '@clack/prompts'
 import { tabMultiselect } from './tab-multiselect.js'
-import { chalk, PACKAGE_ROOT } from './utils.js'
+import { chalk } from './utils.js'
 import { linkSkill, ensureSharedSkills, removeSkillEntry } from './skill-store.js'
+import { resolveTemplateSource } from './template-source.js'
 
 const CATEGORIES = [
   { key: 'skills', label: 'Skills' },
@@ -390,17 +391,9 @@ async function syncSettings(sourceDir, targetDir, selectedHookNames, global, sta
   return 1
 }
 
-/** 默认读取随包模板；仅开发者显式设置环境变量时改用外部目录，不要求仓库权限。 */
-export async function resolveSourceDir() {
-  const explicitSourceDir = process.env.DWY_TEMPLATE_SOURCE_DIR
-  if (explicitSourceDir) {
-    if (!await fs.pathExists(explicitSourceDir)) {
-      throw new Error(`DWY_TEMPLATE_SOURCE_DIR not found: ${explicitSourceDir}`)
-    }
-    return explicitSourceDir
-  }
-
-  return path.join(PACKAGE_ROOT, 'templates', 'ai-tools')
+/** 解析模板源并检查公开模板更新；调用方可注入 homeDir 隔离用户缓存。 */
+export async function resolveSourceDir(options) {
+  return resolveTemplateSource(options)
 }
 
 /** 同步 Claude Skills 与 Hooks；基线和项目 Rules 由总同步入口分别处理。 */
@@ -414,7 +407,7 @@ export async function syncClaude({
   syncTypes = ['skills', 'rules', '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')
   }

package/src/template-source.js

@@ -0,0 +1,218 @@
+import fs from 'fs-extra'
+import os from 'node:os'
+import path from 'node:path'
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
+import { randomUUID } from 'node:crypto'
+import { spinner } from '@clack/prompts'
+import { PACKAGE_ROOT } from './utils.js'
+
+const execFileAsync = promisify(execFile)
+const REMOTE = 'https://github.com/danweiyuancircle/dwy-ai-experience.git'
+const TEMPLATE_PATH = ['dwy-cli', 'templates', 'ai-tools']
+const REVISION_FILE = '.dwy-source-revision'
+
+async function statEntry(file) {
+  return fs.lstat(file).catch(error => {
+    if (error.code === 'ENOENT') return null
+    throw error
+  })
+}
+
+async function requireDirectory(directory) {
+  const stat = await fs.lstat(directory)
+  if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error(`模板目录不能是软链接或文件：${directory}`)
+}
+
+async function validateTemplates(directory) {
+  await requireDirectory(directory)
+  await validateTree(directory)
+  for (const name of ['skills', 'rules', 'hooks']) await requireDirectory(path.join(directory, name))
+  const baseline = path.join(directory, 'AGENTS.md')
+  if (!(await fs.lstat(baseline)).isFile() || !(await fs.readFile(baseline, 'utf8')).trim()) {
+    throw new Error('模板缺少有效 AGENTS.md')
+  }
+}
+
+async function validateTree(directory) {
+  for (const entry of await fs.readdir(directory, { withFileTypes: true })) {
+    if (entry.isSymbolicLink()) throw new Error(`模板不能包含软链接：${entry.name}`)
+    if (entry.isDirectory()) await validateTree(path.join(directory, entry.name))
+  }
+}
+
+async function deadLockExists(lockPath) {
+  const stat = await statEntry(lockPath)
+  if (!stat) return false
+  if (!stat.isFile()) throw new Error(`模板锁无效，保留原文件：${lockPath}`)
+  const owner = await fs.readFile(lockPath, 'utf8').catch(error => {
+    if (error.code === 'ENOENT') return null
+    throw error
+  })
+  if (owner === null) return false
+  const pid = Number(owner.trim())
+  if (!/^[1-9]\d*\s*$/.test(owner) || !Number.isSafeInteger(pid) || pid > 2147483647) {
+    throw new Error(`模板锁无效，保留原文件：${lockPath}`)
+  }
+  try {
+    process.kill(pid, 0)
+  } catch (error) {
+    if (error.code === 'ESRCH') return true
+    if (error.code !== 'EPERM') throw error
+  }
+  throw new Error(`进程 ${pid} 正在更新模板，保留现有锁。`)
+}
+
+async function acquireLock(lockPath, candidate) {
+  while (true) {
+    try {
+      await fs.link(candidate, lockPath)
+      return
+    } catch (error) {
+      if (error.code !== 'EEXIST') throw error
+    }
+    if (!await deadLockExists(lockPath)) continue
+    // 回收也须互斥，避免两个进程删掉对方的新锁；回收中断时按同一协议恢复。
+    const recovery = `${lockPath}.recovery`
+    await acquireLock(recovery, candidate)
+    try {
+      if (await deadLockExists(lockPath)) await fs.unlink(lockPath)
+      try {
+        await fs.link(candidate, lockPath)
+        return
+      } catch (error) {
+        if (error.code !== 'EEXIST') throw error
+      }
+    } finally {
+      await fs.unlink(recovery)
+    }
+  }
+}
+
+async function git(args, cwd) {
+  try {
+    const { stdout } = await execFileAsync('git', ['-c', 'core.hooksPath=/dev/null', ...args], {
+      cwd,
+      // 不加载用户安装的 hooks 或过滤器，避免检出远端内容时执行脚本。
+      env: { ...process.env, GIT_TERMINAL_PROMPT: '0', GIT_CONFIG_NOSYSTEM: '1', GIT_CONFIG_GLOBAL: '/dev/null' },
+      // 首次检出要获取整套模板，不能沿用轻量版本检查的短超时。
+      timeout: ['clone', 'checkout', 'fetch', 'reset'].includes(args[0]) ? 300000 : 15000,
+      maxBuffer: 1024 * 1024,
+    })
+    return stdout.trim()
+  } catch (error) {
+    throw new Error(`Git 获取模板失败（${error.code || error.signal}）`)
+  }
+}
+
+async function refreshTemplates(root, cache) {
+  await fs.ensureDir(root)
+  await requireDirectory(root)
+  const lockPath = path.join(root, 'template-source.lock')
+  const candidate = path.join(root, `.template-source-lock-${randomUUID()}`)
+  await fs.writeFile(candidate, `${process.pid}\n`, { flag: 'wx' })
+  try {
+    await acquireLock(lockPath, candidate)
+  } finally {
+    await fs.unlink(candidate)
+  }
+  let staging
+  const previous = path.join(root, '.template-source.previous')
+  try {
+    if (await statEntry(cache)) await requireDirectory(cache)
+    if (await statEntry(previous)) {
+      await validateTemplates(previous)
+      if (await statEntry(cache)) {
+        await validateTemplates(cache)
+        await fs.remove(previous)
+      } else {
+        await fs.rename(previous, cache)
+      }
+    }
+    const revision = (await git(['ls-remote', '--exit-code', REMOTE, 'refs/heads/master'], root)).split(/\s/)[0]
+    if (!/^[a-f\d]{40,64}$/.test(revision)) throw new Error('远端 master 版本无效')
+    if (await statEntry(cache)) {
+      try {
+        await validateTemplates(cache)
+        if ((await fs.readFile(path.join(cache, REVISION_FILE), 'utf8')).trim() === revision) return
+      } catch {
+        // 本地缓存不完整时重新获取，不能只凭版本标记跳过内容校验。
+      }
+    }
+    staging = await fs.mkdtemp(path.join(root, '.template-source-'))
+    const storedRepository = path.join(root, 'template-repository')
+    const reuse = !!await statEntry(storedRepository)
+    const repository = reuse ? storedRepository : path.join(staging, 'repository')
+    if (reuse) {
+      await requireDirectory(repository)
+      await requireDirectory(path.join(repository, '.git'))
+      await git(['fetch', '--depth=1', '--filter=blob:none', REMOTE, 'master'], repository)
+      await git(['reset', '--hard', 'FETCH_HEAD'], repository)
+    } else {
+      await git(['clone', '--depth=1', '--filter=blob:none', '--no-checkout', '--single-branch',
+        '--branch', 'master', REMOTE, repository], staging)
+      await git(['sparse-checkout', 'set', '--cone', TEMPLATE_PATH.join('/')], repository)
+      await git(['checkout', '--force', 'master'], repository)
+    }
+    let candidate = repository
+    for (const segment of TEMPLATE_PATH) {
+      candidate = path.join(candidate, segment)
+      await requireDirectory(candidate)
+    }
+    await validateTemplates(candidate)
+    const next = path.join(staging, 'templates')
+    await fs.copy(candidate, next)
+    await fs.writeFile(path.join(next, REVISION_FILE), await git(['rev-parse', 'HEAD'], repository))
+    if (!reuse) await fs.rename(repository, storedRepository)
+    const hadCache = !!await statEntry(cache)
+    if (hadCache) await fs.rename(cache, previous)
+    try {
+      await fs.rename(next, cache)
+    } catch (error) {
+      if (hadCache) await fs.rename(previous, cache)
+      throw error
+    }
+    if (hadCache) await fs.remove(previous)
+  } finally {
+    try {
+      if (staging) await fs.remove(staging)
+    } finally {
+      await fs.unlink(lockPath)
+    }
+  }
+}
+
+/**
+ * 从固定公开仓库更新用户模板缓存；只读取已验证的目录，不执行模板脚本。
+ * 显式目录优先；DWY_HOME 优先于注入 homeDir，更新失败保留缓存，无有效缓存才用随包模板。
+ */
+export async function resolveTemplateSource({ homeDir = os.homedir() } = {}) {
+  const explicitSourceDir = process.env.DWY_TEMPLATE_SOURCE_DIR
+  if (explicitSourceDir) {
+    if (!await fs.pathExists(explicitSourceDir)) {
+      throw new Error(`DWY_TEMPLATE_SOURCE_DIR not found: ${explicitSourceDir}`)
+    }
+    return explicitSourceDir
+  }
+  const root = process.env.DWY_HOME || path.join(homeDir, '.dwy')
+  const cache = path.join(root, 'template-source')
+  const progress = process.stdout.isTTY ? spinner() : null
+  progress?.start('正在检查 AI 模板更新，首次获取可能较慢')
+  try {
+    await refreshTemplates(root, cache)
+    progress?.stop('AI 模板已就绪')
+    return cache
+  } catch (error) {
+    progress?.stop('模板更新未完成，正在检查本地来源')
+    try {
+      await validateTemplates(cache)
+    } catch {
+      const bundled = path.join(PACKAGE_ROOT, 'templates', 'ai-tools')
+      await validateTemplates(bundled)
+      console.warn(`模板更新失败（${error.message}）；无有效缓存，回退随包模板。`)
+      return bundled
+    }
+    console.warn(`模板更新失败（${error.message}）；继续使用本地缓存。`)
+    return cache
+  }
+}

package/templates/ai-tools/AGENTS.md

@@ -120,16 +120,16 @@
 - 需要用户决策的复杂多步骤流程
 - 用户明确要求详细解释时
 
-## 新功能开发前先找工具
+## 使用新框架或工具前先找配套能力
 
-每次开发新功能，在编码前必须查找与任务匹配的 Skill、MCP、CLI 等现成能力，并自行评估使用风险。适用于功能设计、实现和验证；不因普通文案修改或小修复强制展开选型。
+首次使用新的框架、SDK、平台、服务或开发工具时，在操作前必须查找其配套的 Skill、MCP 或 CLI。有适用的就按说明使用，帮助完成设计、实现或验证；没有合适的就按正常方式继续，不强求安装。已核实且仍适用的结果直接复用，普通文案修改或熟悉的小修复不重复检索。
 
 ### 查找与选择
 
-1. 先检查当前已安装、已连接的 Skill、MCP、CLI，以及项目已有工具；匹配时先读使用说明和权限要求。
+1. 先检查当前已安装、已连接的 Skill、MCP、CLI，以及项目已有工具，寻找与当前框架和任务匹配的能力；匹配时先读使用说明和权限要求。
 2. 再查对应平台、框架或产品的官方文档、官方仓库与工具目录，寻找官方提供或明确推荐的能力；本轮已核实且覆盖当前任务的来源可以复用。
 3. 官方方案不适用或不存在时，查找当前生态中用户基础广、持续维护的开源社区方案。结合维护者身份、近期发布、问题处理、文档和实际使用情况判断成熟度，不能只看 Star 数、下载量或搜索排名。
-4. 按任务匹配度、风险、接入成本和维护成本决定是否采用。已有工具能完成任务时优先复用，不为凑工具而安装；未找到合适方案时说明检索范围和原因，再按项目原有方式继续。
+4. 按任务匹配度、风险、接入成本和维护成本决定是否采用。已有工具能完成任务时优先复用；找到合适能力后实际用于当前任务，不能只列出名称。未找到或不适用时简要说明，继续当前任务，不为凑工具而安装或反复扩大检索。
 
 Skill 用于工作指导，MCP 用于连接能力，CLI 用于执行操作，按任务选择需要的类型，不要求三类都安装。无法联网或无法核实来源时，明确说明限制，不把未验证的候选当作可信工具执行。
 

package/templates/ai-tools/skills//351/200/232/347/224/250/dwy-scope-guard/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: dwy-scope-guard
+description: 用户提出新增功能、顺手扩展、收录想法，或开始规划下一个版本、查看待办想法、担心本期功能过多时使用。适用于持续迭代中的版本范围与想法管理；单纯修复既有行为、执行已确认范围内的任务时不重复评审。
+---
+
+# 版本克制与想法收录
+
+帮助用户判断想法是否值得现在做，让每个版本先完成可用闭环。敢于指出范围膨胀，把暂缓的想法可靠保存，并在新版本规划时重新提醒。
+
+## 工作边界
+
+- 针对需求证据和交付取舍提出异议，不评价用户的性格或欲望，也不迎合每个想法。
+- 用户明确限定“只分析、先分析、不改文件”时不开发、不持久化，返回待收录内容；常规想法评估按第 3 节收录。明确要求实施时，给出一次简短范围建议后，在授权范围内执行。不能擅自删除已约定功能；用户听取建议后仍决定继续，不反复劝阻。
+- 安全、数据完整性、输入校验、错误处理、可访问性和必要验证属于可用性，不因控制范围而省略。
+- 提醒发生在本 Skill 被调用、识别到新增功能或新版本规划时。自动触发取决于宿主发现能力；不承诺后台监控、定时或跨会话主动推送，不自行配置通知服务。
+
+## 1. 先确认当前版本的负担
+
+读取当前产品的版本计划、变更记录、验收记录及相关改动，优先复用已有资料。多包仓库按当前产品或包判断，不把其他包的工作算进来。
+
+- 确认上一个已发布或已验收版本、本期目标和已承诺范围；最新提交或标签本身不能证明版本可用。
+- 区分本期已验证、已实现未验证、尚未完成的内容，关注新增用户能力、跨模块依赖、数据迁移和验收成本，不只数功能或代码行数。
+- 缺少基线或进度证据时明确说明，不编造版本差异、工期或完成率。仅在影响决策时问一个关键问题，其余给出带假设的建议。
+
+## 2. 每个新想法先给判断
+
+结合上下文简短分析：解决谁的什么问题、证据是什么、不做的影响、能否用现有能力满足，以及最小方案引入多少实现、运维和验证负担。无证据的收益标为假设，不机械追问一整套问题。
+
+先给结论：**本期做 / 缩小后做 / 放到后续版本 / 先验证需求**，随后说明理由、最小范围和收尾标准。
+
+- 新想法支撑本期核心闭环、有实际需求依据且负担可控时，建议本期做。
+- 已有多项未完成或未验收内容、新增独立使用场景、引入较重依赖，或不断以“顺手、以后可能用到、既然做了就一起”扩张时，具体指出对交付的影响，优先建议收尾或拆阶段。
+- 需要拆阶段时，每阶段都要有独立可用结果和可判断的验收条件；后续增强进入清单，不作为本期交付的前置条件。
+- 本期确需增加范围时，说明新增成本，并建议替换或推迟什么；取舍由用户决定。不设任意功能数量上限，不为凑齐固定数量增加需求。
+- 已分析并确认过的同一想法，直接沿用结论；只有范围、证据或依赖发生变化时才重评。
+
+## 3. 把想法存到项目里
+
+先查项目指定或已有的想法池、backlog、版本路线图，沿用其位置和格式；没有时在项目根创建 `.dwy/ideas.md`。不写进 Skill 安装目录、全局个人记忆或其他项目，不另建重复清单。多产品清单按产品或包分组。
+
+用户要求收录，或常规分析产生暂缓想法时，在任务允许写文件的情况下直接记录，不逐条重复确认。明确限定仅分析、纯只读请求或没有写权限时只给待收录内容，明确尚未保存。不得把敏感数据、凭据写入清单，也不因已有外部系统而擅自创建远端任务。
+
+记录前按问题和方案查重；已有同一想法时补充证据和决定，不重复新增，不覆盖无关记录。每项保留：
+
+- 稳定编号、简短名称、提出日期与来源。
+- 用户问题和需求证据；用户原意与 AI 建议分开，未知项写“待确认”。
+- 最小可用方案、暂缓原因与重评条件。
+- 状态：候选 / 本期已选 / 已交付 / 已放弃；目标版本未定就写“未定”，不自行承诺下版必做。
+
+没有既有格式时，可用下列 Markdown 结构，按真实信息填写：
+
+```markdown
+# 想法清单
+
+## 当前版本
+
+- 上一可用版本：待确认
+- 本期目标与范围：待确认
+- 收尾与验收条件：待确认
+
+## IDEA-001：想法名称
+
+- 提出日期与来源：实际日期；用户原话或需求链接
+- 状态 / 目标版本：候选 / 未定
+- 问题与证据：具体问题；无证据时注明假设
+- 最小方案：最小可用结果；AI 建议单独标明
+- 暂缓原因：当前取舍
+- 重评条件：下一版本规划，或具体反馈、依赖条件满足时
+```
+
+已有版本计划时引用它，不重复维护一份当前范围。实际写入后回读相关条目，报告保存位置和编号；写入失败不得声称已收录。仅更新清单不代表功能实现或版本交付。
+
+## 4. 新版本规划时重新提醒
+
+用户说“开始下个版本、下一版做什么、排版本、还有哪些想法”等时，先读取持久化清单，再提出计划，不依赖聊天记忆。
+
+1. 核对上一版实际交付和未完成项；未完成项先明确处置，不默认为已完成或偷偷带入下一版。
+2. 主动提醒候选想法，说明哪些到了重评时机、哪些仍缺证据或依赖；没有到期候选时如实说明。
+3. 结合新反馈和本期目标推荐少量最相关项，解释取舍，避免把整个想法池塞进版本。用户未选定前保持候选状态。
+4. 用户确定范围后，记录本期目标、已选编号、最小范围和收尾标准，更新对应状态及目标版本。用户决定暂缓或撤回本期项时恢复候选并保留原因；同一轮规划不反复提醒已决定的事项。
+5. 只有对应验收证据成立才标为已交付；未验收的实现仍保留未完成说明。用户明确放弃时标为已放弃并保留原因，不删除历史、不再次推荐；用户主动重提时再更新。
+
+清单不存在时说明没有可读取的历史想法，不编造遗漏记录。不要只因查询清单就创建空文件。
+
+## 输出示例
+
+用户：“记账功能还没验收，我还想这版一起加 AI 分析、家庭共享和多币种。”
+
+> **建议：先完成本期验收，三个想法放到后续版本。** 基础录入尚未验收，家庭共享会增加权限和同步，多币种会增加换算与数据处理，都会扩大本期验证范围。先走通“录入—保存—查看”及关键失败路径；三个想法分别收录，需求证据先标为待确认。开始规划下一版时，再结合反馈提醒并重新排序。
+
+只有实际保存后才补充收录位置与编号；此示例不代表已经写入想法清单。