create-yss-spec 3.0.1 → 3.1.0

package/template/.agents/skills/teach/SKILL.md

@@ -1,140 +0,0 @@
----
-name: teach
-description: Teach the user a new skill or concept, within this workspace.
-disable-model-invocation: true
-argument-hint: "What would you like to learn about?"
----
-
-The user has asked you to teach them something. This is a stateful request - they intend to learn the topic over multiple sessions.
-
-## Teaching Workspace
-
-Treat the current directory as a teaching workspace. The state of their learning is captured in this directory in several files:
-
-- `MISSION.md`: A document capturing the _reason_ the user is interested in the topic. This should be used to ground all teaching. Use the format in [MISSION-FORMAT.md](./MISSION-FORMAT.md).
-- `./reference/*.html`: A directory of reference materials. These are the compressed learnings from the lessons - cheat sheets, reference algorithms, syntax, yoga poses, glossaries. They are the raw units of learning. They should be beautiful documents which print out well, and are designed for quick reference.
-- `RESOURCES.md`: A list of resources which can be explored to ground your teaching in contextual knowledge, or to acquire knowledge and wisdom. Use the format in [RESOURCES-FORMAT.md](./RESOURCES-FORMAT.md).
-- `./learning-records/*.md`: A directory of learning records, which capture what the user has learned. These are loosely equivalent to architectural decision records in software development - they capture non-obvious lessons and key insights that may need to be revised later, or drive future sessions. These should be used to calculate the zone of proximal development. They are titled `0001-<dash-case-name>.md`, where the number increments each time. Use the format in [LEARNING-RECORD-FORMAT.md](./LEARNING-RECORD-FORMAT.md).
-- `./lessons/*.html`: A directory of lessons. A **lesson** is a single, self-contained HTML output that teaches one tightly-scoped thing tied to the mission. This is the primary unit of teaching in this workspace.
-- `./assets/*`: Reusable **components** shared across lessons. See [Assets](#assets).
-- `NOTES.md`: A scratchpad for you to jot down user preferences, or working notes.
-
-## Philosophy
-
-To learn at a deep level, the user needs three things:
-
-- **Knowledge**, captured from high-quality, high-trust resources
-- **Skills**, acquired through highly-relevant interactive lessons devised by you, based on the knowledge
-- **Wisdom**, which comes from interacting with other learners and practitioners
-
-Before the `RESOURCES.md` is well-populated, your focus should be to find high-quality resources which will help the user acquire knowledge. Never trust your parametric knowledge.
-
-Some topics may require more skills than knowledge. Learning more about theoretical physics might be more knowledge-based. For yoga, more skills-based.
-
-### Fluency vs Storage Strength
-
-You should be careful to split between two types of learning:
-
-- **Fluency strength**: in-the-moment retrieval of knowledge
-- **Storage strength**: long-term retention of knowledge
-
-Fluency can give the user an illusory sense of mastery, but storage strength is the real goal. Try to design lessons which build long-term retention by desirable difficulty:
-
-- Using retrieval practice (recall from memory)
-- Spacing (distributing practice over time)
-- Interleaving (mixing up different but related topics in practice - for skills practice only)
-
-## Lessons
-
-A lesson is the main thing you produce — the unit in which knowledge and skills reach the user. Each lesson is one self-contained HTML file, saved to `./lessons/` and titled `0001-<dash-case-name>.html` where the number increments each time.
-
-A lesson should be **beautiful** — clean, readable typography and layout — since the user will return to these later to review. Think Tufte.
-
-The lesson should be short, and completable very quickly. Learners' working memory is very small, and we need to stay within it. But each lesson should give the user a single tangible win that they can build on. It should be directly tied to the mission, and should be in the user's zone of proximal development.
-
-If possible, open the lesson file for the user by running a CLI command.
-
-Each lesson should link via HTML anchors to other lessons and reference documents.
-
-Each lesson should recommend a primary source for the user to read or watch. This should be the most high-quality, high-trust resource you found on the topic.
-
-Each lesson should contain a reminder to ask followup questions to the agent. The agent is their teacher, and can assist with anything that's unclear.
-
-## Assets
-
-Lessons are built from reusable **components**, stored in `./assets/`: stylesheets, quiz widgets, simulators, diagram helpers — anything a second lesson could reuse.
-
-Reuse is the default, not the exception. Before authoring a lesson, read `./assets/` and build from the components already there. When a lesson needs something new and reusable, write it as a component in `./assets/` and link to it — never inline code a future lesson would duplicate.
-
-A shared stylesheet is the first component every workspace earns: every lesson links it, so the lessons look like one consistent course rather than a pile of one-offs. As the workspace grows, so should the component library.
-
-## The Mission
-
-Every lesson should be tied into the mission - the reason that the user is interested in learning about the topic.
-
-If the user is unclear about the mission, or the `MISSION.md` is not populated, your first job should be to question the user on why they want to learn this.
-
-Failing to understand the mission will mean knowledge acquisition is not grounded in real-world goals. Lessons will feel too abstract. You will have no way of judging what the user should do next.
-
-Missions may change as the user develops more skills and knowledge. This is normal - make sure to update the `MISSION.md` and add a learning record to capture the change. Confirm with the user before changing the mission.
-
-## Zone Of Proximal Development
-
-Each lesson, the user should always feel as if they are being challenged 'just enough'.
-
-The user may specify an exact thing they want to learn. If they don't, figure out their zone of proximal development by:
-
-- Reading their `learning-records`
-- Figuring out the right thing to teach them based on their mission
-- Teach the most relevant thing that fits in their zone of proximal development
-
-## Knowledge
-
-Lessons should be designed around a skill the user is going to learn. The knowledge in the lesson should be only what's required to acquire that skill. You teach the knowledge first, then get the user to practice the skills via an interactive feedback loop.
-
-Knowledge should first be gathered from trusted resources. Use `RESOURCES.md` to keep track of them. Lessons should be littered with citations - links to external resources to back up any claim made. This increases the trustworthiness of the lesson.
-
-For acquiring knowledge, difficulty is the enemy. It eats working memory you need for understanding.
-
-## Skills
-
-If knowledge is all about acquisition, skills are about durability and flexibility. Make the knowledge stick.
-
-For skill acquisition, difficulty is the tool. Effortful retrieval is what builds storage strength. Skills should be taught through interactive lessons. There are several tools at your disposal:
-
-- Interactive lessons, using quizzes and light in-browser tasks
-- Lessons which guide the user through a list of real-world steps to take (for instance, yoga poses)
-
-Each of these should be based on a **feedback loop**, where the user receives feedback on their performance. This feedback loop should be as tight as possible, giving feedback immediately - and ideally automatically.
-
-For quizzes, each answer should be exactly the same number of words (and characters, if possible). Don't give the user any clues about the answer through formatting.
-
-## Acquiring Wisdom
-
-Wisdom comes from true real-world interaction - testing your skills outside the learning environment.
-
-When the user asks a question that appears to require wisdom, your default posture should be to attempt to answer - but to ultimately delegate to a **community**.
-
-A community is a place (online or offline) where the user can test their skills in the real world. This might be a forum, a subreddit, a real-world class (budget permitting) or a local interest group.
-
-You should attempt to find high-reputation communities the user can join. If the user expresses a preference that they don't want to join a community, respect it.
-
-## Reference Documents
-
-While creating lessons, you should also create reference documents. Lessons can reference these documents - they are useful for tracking raw units of knowledge useful across lessons.
-
-Lessons will rarely be revisited later - reference documents will be. They should be the compressed essence of the lesson, in a format designed for quick reference.
-
-Some learning topics lend themselves to reference:
-
-- Syntax and code snippets for programming
-- Algorithms and flowcharts for processes
-- Yoga poses and sequences for yoga
-- Exercises and routines for fitness
-- Glossaries for any topic with its own nomenclature
-
-Glossaries, in particular, are an essential reference. Once one is created, it should be adhered to in every lesson.
-
-## `NOTES.md`
-
-The user will sometimes express preferences of how they want to be taught, or things you should keep in mind. This is the place to record those preferences, so you can refer back to them when designing lessons or working with the user.

package/template/.agents/skills/teach/agents/openai.yaml

@@ -1,5 +0,0 @@
-interface:
-  display_name: "Teach"
-  short_description: "Learn a concept in a guided workspace"
-policy:
-  allow_implicit_invocation: false

package/template/.agents/skills/writing-beats/SKILL.md

@@ -1,67 +0,0 @@
----
-name: writing-beats
-description: Writing, exploit — assemble raw material into a journey of beats, grounding each term before a beat leans on it.
-disable-model-invocation: true
----
-
-<what-to-do>
-
-The user has passed (or will pass) a markdown file of raw material. This is **exploit**: the exploring is done, the pile is fixed — commit to a path through it and mine the pile to fill each beat.
-
-If the user did not say where to save the article, ask once and remember the path.
-
-Then run a beat-by-beat journey, choose-your-own-adventure style:
-
-1. **Establish the prerequisites.** Before any beats, settle with the user what the audience already knows walking in — the concepts that are **grounded** from the start. Everything else must be grounded by a beat before a later beat can use it. See [Grounding](#grounding).
-2. Write 2–3 candidate **starting beats**, drawn from the raw material. Each is a different entry point into the article. Each may only lean on grounded concepts; note what new concepts each one grounds. Show the user the beats before writing to the article file. The user picks one. Preview what beats that pick unlocks — as if the user is seeing a little way down the path.
-3. Once the user picks a starting beat, write **only that beat** to the article file. A beat may be one sentence or several paragraphs — whatever that beat naturally is. Stop there.
-4. Re-read the article file from disk. Then offer 2–3 candidate **next beats** — different directions the journey could pivot to from where the article now stands. Each must be reachable from the current grounded set; note what each one grounds.
-5. Loop steps 3–5 until the article reaches a natural end.
-
-</what-to-do>
-
-<supporting-info>
-
-## Grounding
-
-Every **concept** has to be **grounded** before a beat can lean on it: the audience either walked in knowing it or met it in an earlier beat. A beat that reaches for an ungrounded concept loses the reader — that is the one move the journey can't make. The unit is the concept, not the word for it: a beat can lean on an idea the reader lacks even with no jargon in sight. Where a concept has a name — a **term** — grounding it means landing the idea and the term together.
-
-A concept gets grounded one of two ways:
-
-- **Prerequisite** — grounded before the first beat. The audience brings it. Fixed at the start.
-- **Introduced** — a beat establishes it, and from then on it's grounded for every later beat.
-
-So each beat does two jobs: it **requires** concepts that are already grounded, and it **grounds** new ones. Keep a running list of what's grounded so far, and update it each time a beat lands.
-
-This is what shapes the choose-your-own-adventure. A candidate beat is only reachable if everything it requires is already grounded; picking a beat that grounds concept X unlocks every beat that was waiting on X. When you offer next beats, they must all be reachable from the current grounded set — and say what each one grounds, so the user can see which paths it opens.
-
-The big lever is what you make a prerequisite versus what you ground inside the piece. Demand too much up front and you shut out readers who don't have it; ground too much inside and the early beats drown in definitions. Settle this with the user when you establish prerequisites, and revisit it whenever a tempting beat turns out to require a concept nothing has grounded yet — the fix is either a grounding beat before it, or promoting the concept to a prerequisite.
-
-## What is a beat
-
-A beat is one move in the journey. It does one thing — sets a scene, lands a point, asks a question, drops an aside, twists the angle. Then it stops, leaving the reader at a place where the next beat can pivot.
-
-A beat is sized by what it needs:
-
-- A single sentence if that's all the move is ("And then nothing happened for three weeks.").
-- A short paragraph if the move needs setup.
-- Multiple paragraphs if the beat is a self-contained vignette, argument, or example.
-
-If a "beat" needs five paragraphs and three subheadings, it's not a beat — it's two beats glued together. Split it.
-
-## Pulling from the pile
-
-Pull material from the raw pile to populate each beat. You can paraphrase, split, recombine, or quote. The pile is a quarry.
-
-## Ending the journey
-
-The article ends when the journey is complete — not when the pile is empty. Most piles will have leftover fragments that don't make it in. That is fine; that is the point of having more raw material than you need.
-
-## Writing rhythm
-
-- Append one beat at a time. Never write ahead.
-- Re-read the article file from disk before every write. Preserve user edits absolutely.
-- If the user edits a previous beat substantially, let it change what comes next.
-- If the user says "rewrite that beat" or "go back and try a different beat 3", do it — edit in place, leave the rest alone.
-
-</supporting-info>

package/template/.agents/skills/writing-beats/agents/openai.yaml

@@ -1,5 +0,0 @@
-interface:
-  display_name: "Writing Beats"
-  short_description: "Assemble raw material into beats"
-policy:
-  allow_implicit_invocation: false

package/template/.agents/skills/writing-fragments/SKILL.md

@@ -1,79 +0,0 @@
----
-name: writing-fragments
-description: Writing, explore — mine raw fragments, no structure yet.
-disable-model-invocation: true
----
-
-<what-to-do>
-
-This is pure **explore**: widen the space of what could be written without committing to structure — committing is _exploit_, a separate skill's job. Run a grilling session that produces fragments, interviewing the user relentlessly about whatever they want to write about. Imposing phases, outlines, or article structure is out of scope here.
-
-As fragments emerge from either side of the conversation, append them to a single markdown file.
-
-If the user did not pass a path, ask once where to save the document, then remember it for the rest of the session.
-
-Capture fragments from the very first thing the user says, including the initial prompt.
-
-On first write, put a single H1 at the top with a working title (it can change later) and nothing else — no metadata, no TOC, no date.
-
-</what-to-do>
-
-<supporting-info>
-
-## What is a fragment
-
-A fragment is any piece of text that might survive into the final article. It must be _readable by the author_ — the author can tell what it means — but it does not need to define its terms or be comprehensible to a cold reader. The bar is "is this a piece of good writing?", not "is this a self-contained argument?"
-
-Fragments are deliberately heterogeneous. Examples of what could be a fragment:
-
-- A sharp sentence you'd want to deploy somewhere but don't yet know where.
-- A claim with a one-line justification.
-- A vignette: a thing that happened, a code snippet, a scenario, an analogy.
-- A half-thought: "something about how X feels like Y, work this out later."
-- A quote, a piece of dialogue, an overheard line.
-- A list of related observations that hang together by feel.
-- A complaint, a confession, a punchline.
-- A **leading word** — a compact metaphor or coinage the whole piece can hang on (one term that names the idea, the way _tracer bullets_ or _fog of war_ names a whole pattern).
-
-Of these, the leading word is the most valuable fragment to land. It is load-bearing: name the right one in explore and it shapes the structure, the transitions, and the title later — paying dividends through the entire exploit phase. When the conversation circles a recurring idea, push to coin a word for it.
-
-The novelist's diary is the model: years of unstructured noticings that later get mined for raw material. Fragments are noticings.
-
-## File format
-
-```markdown
-# Working title
-
-A first fragment lives here.
-
-It can be multiple paragraphs. It can include lists, code, quotes — whatever
-shape the fragment naturally takes.
-
----
-
-A second fragment.
-
----
-
-> A quoted line that the user wants to keep around.
-
-A reaction to it.
-
----
-
-- A cluster of related observations
-- That hang together by feel
-- And want to be near each other
-```
-
-Fragments are separated by a horizontal rule (`\n---\n`). No headings inside the body. No tags. No order beyond the order they were added.
-
-## Writing rhythm
-
-Append silently. Don't ask permission for each fragment. Mention what you added in passing ("adding that"), but don't interrupt the conversation with save dialogs.
-
-Before every write: re-read the file from disk. The user may have edited, reordered, or deleted fragments between turns — preserve their changes. Never overwrite the file; only append (or, if the user asks, edit a specific fragment in place).
-
-The user can say "cut the last one", "rewrite that one sharper", "merge those two" at any time. Treat those as first-class instructions.
-
-</supporting-info>

package/template/.agents/skills/writing-fragments/agents/openai.yaml

@@ -1,5 +0,0 @@
-interface:
-  display_name: "Writing Fragments"
-  short_description: "Mine raw writing fragments"
-policy:
-  allow_implicit_invocation: false

package/template/.agents/skills/writing-shape/SKILL.md

@@ -1,79 +0,0 @@
----
-name: writing-shape
-description: Writing, exploit — shape raw material into an article, paragraph by paragraph.
-disable-model-invocation: true
----
-
-<what-to-do>
-
-The user has passed (or will pass) a markdown file of raw material. Treat it as the input pile — anything from a tidy list of fragments to a wall of unstructured prose to a transcript. The format does not matter. Read it end-to-end before doing anything else.
-
-Then run a shaping session that produces a separate article document. This is **exploit**: the exploring is done, the pile is fixed — commit to a structure and mine the pile to fill it. Do not edit the raw material file — it is read-only to this skill.
-
-If the user did not say where to save the article, ask once and remember the path.
-
-</what-to-do>
-
-<supporting-info>
-
-## The loop
-
-1. **Read the pile.** Read the input file in full. Form a sense of what's in it.
-2. **Establish the prerequisites.** Settle with the user what the reader knows walking in — the concepts that are **grounded** from the start. Everything else must be grounded by a block before a later block can lean on it. See [Grounding](#grounding).
-3. **Draft 2–3 candidate openings.** Each opening should imply a different thesis or angle for the article. Show all of them. Force the user to pick or compose a hybrid. The chosen opening defines what the rest of the article must do.
-4. **Grow paragraph by paragraph.** After the opening lands, ask "given this opening, what does the reader need to hear next?" Pull material from the pile to answer. The next block may only lean on grounded concepts, and grounds new ones as it lands. Argue about the form the next block takes — a paragraph, a list, a table, a callout, a quote, a code block. Each format choice should be deliberate and defensible.
-5. **Append to the article file as you go.** Don't batch. Write each agreed paragraph or block immediately so the user can see the article taking shape.
-6. **Loop step 4 until the article is done.** The user decides when it's done.
-
-## Grounding
-
-Every **concept** has to be **grounded** before a block can lean on it: the reader either walked in knowing it or met it in an earlier block. A block that reaches for an ungrounded concept loses the reader. The unit is the concept, not the word for it — a block can lean on an idea the reader lacks even with no jargon in sight. Where a concept has a name — a **term** — grounding it means landing the idea and the term together.
-
-A concept gets grounded one of two ways:
-
-- **Prerequisite** — grounded before the opening. The reader brings it. Fixed at the start.
-- **Introduced** — a block establishes it, and from then on it's grounded for the rest of the article.
-
-Keep a running list of what's grounded. When you ask "what does the reader need to hear next?", an ungrounded concept the next move needs is itself the answer: ground it first — here or in an earlier block — or you can't make the move. This is the gap-naming of [Pulling from the pile](#pulling-from-the-pile) one level up: there the pile is missing material; here the article is missing a foundation.
-
-The lever is what you make a prerequisite versus what you ground inside the article. Demand too much up front and you shut readers out; ground too much inside and the opening drowns in definitions. Settle it with the user when you establish prerequisites.
-
-## Conversational feel
-
-This is a grilling session inverted. In ideation, the question was "what are you actually noticing?" Here it's "what is this article actually arguing, and in what order does the reader need to hear it?" Push back. Refuse to let weak transitions slide. If a paragraph doesn't earn its place, cut it.
-
-Specific moves to keep using:
-
-- "What does this paragraph do for the reader that the previous one didn't?"
-- "If I cut this, what breaks?"
-- "Is this prose, or should it be a list? Why prose?"
-- "This sentence is doing two jobs — split it or pick one."
-- "The opening promised X. We've drifted to Y. Either re-thread it or change the opening."
-
-## Pulling from the pile
-
-Treat the raw material as a quarry, not a script. Pull a fragment, rework it to fit the surrounding paragraph, and place it. A fragment may be split across multiple paragraphs, merged with another, or paraphrased. The pile's job is to be mined; the article's job is to read as one voice.
-
-If the pile lacks something the article needs, name the gap explicitly: "We need an example here and the pile doesn't have one — give me one now or we cut this section."
-
-## Format arguments to actually have
-
-When choosing how to render a block, weigh these tradeoffs out loud with the user, not silently:
-
-- **Prose vs. list.** Prose carries argument; lists carry parallel items. If items aren't truly parallel, prose is better. If they are, a list is faster to scan.
-- **Inline vs. callout.** Tips, warnings, and asides go in callouts (`> [!TIP]`, `> [!NOTE]`) — but only if they'd genuinely derail the main argument inline. Otherwise leave them inline.
-- **Table vs. repeated structure.** If the same shape repeats 3+ times with the same fields, a table. Otherwise prose with bold leads.
-- **Quote vs. paraphrase.** Quote when the original wording is the point. Paraphrase when only the idea matters.
-- **Code block vs. inline code.** Multi-line, runnable, or illustrative → block. Single token or identifier → inline.
-
-## Writing rhythm
-
-Append to the article file as each block is agreed. Re-read the file from disk before every write — the user may have edited between turns. Never overwrite blindly. If the user wants a paragraph rewritten, edit that specific paragraph in place; leave the rest alone.
-
-## Out of scope
-
-- Mining for new fragments that aren't in the pile (handle gaps as in "Pulling from the pile").
-- Editing the raw material file.
-- Publishing, formatting for a specific platform, or adding frontmatter the user didn't ask for.
-
-</supporting-info>

package/template/.agents/skills/writing-shape/agents/openai.yaml

@@ -1,5 +0,0 @@
-interface:
-  display_name: "Writing Shape"
-  short_description: "Shape raw material into an article"
-policy:
-  allow_implicit_invocation: false

package/template/.agents/skills/yss-microapp-commit/SKILL.md

@@ -1,201 +0,0 @@
----
-name: microapp-commit
-description: Use when committing or analyzing changes in a YSS micro-frontend application repo and a Conventional Commit message is needed; do not use for the YSS UI component library repo.
----
-
-# 微应用提交规范 Skill
-
-目录与锁文件身份是 `yss-microapp-commit`；Agent 发现名是 `microapp-commit`。二者指向同一技能，注册表以 alias 对齐。
-
-## 📋 目标
-
-帮助 AI 为微应用项目生成符合 **Conventional Commits** 规范的 Git 提交信息，支持智能分析变更内容并处理复杂提交场景。
-
-## 🔍 规范格式
-
-```
-<type>(<scope>): [模块名] <中文简短描述>
-
-- <中文详细描述 1>
-- <中文详细描述 2>
-```
-
-- **type**: 变更类型（必选）
-- **scope**: 影响范围（必选，见下方 Scope 列表）
-- **[模块名]**: 具体模块标识（可选，推荐使用）
-- **subject**: 简短描述（必选，**必须使用中文**）
-- **body**: 详细描述（可选，建议使用列表形式列出具体变更点，**必须使用中文**）
-
-## 🎯 Type 选择指南
-
-| Type | 说明 | 适用场景 | 示例 |
-|------|------|----------|------|
-| **feat** | 新功能 | 新增页面、组件、API 方法 | `feat(views): [UserManage] 新增用户列表页面` |
-| **fix** | 修复 Bug | 修复逻辑错误、接口问题 | `fix(api): [AuthService] 修复 token 刷新失败` |
-| **docs** | 文档变更 | README、注释更新 | `docs: 更新部署文档` |
-| **style** | 代码格式 | 格式化、空格、分号等 | `style(views): 格式化代码` |
-| **refactor** | 代码重构 | 优化结构，不改变功能 | `refactor(hooks): 重构 useRequest 逻辑` |
-| **perf** | 性能优化 | 提升性能的代码修改 | `perf(views): 优化列表渲染性能` |
-| **test** | 测试相关 | 添加或修改测试用例 | `test(utils): 添加日期格式化测试` |
-| **chore** | 杂项 | 构建工具、依赖更新 | `chore(deps): 升级 vite 版本` |
-| **build** | 构建系统 | 修改构建配置 | `build: 调整 vite 打包配置` |
-| **ci** | CI 配置 | GitLab CI、Docker 配置 | `ci: 优化构建流水线` |
-
-## 📂 Scope 选择指南
-
-根据变更文件所在目录选择 scope：
-
-| Scope | 对应目录 | 说明 |
-|-------|----------|------|
-| `views` | `src/views/` | 页面视图组件 |
-| `api` | `src/api/` | API 接口层 |
-| `components` | `src/components/` | 公共组件 |
-| `hooks` | `src/hooks/` | 自定义 Hooks |
-| `utils` | `src/utils/` | 工具函数 |
-| `styles` | `src/styles/` | 全局样式 |
-| `store` | `src/store/` | Pinia 状态管理 |
-| `router` | `src/router/` | 路由配置 |
-| `config` | `src/config/` | 项目配置 |
-| `layout` | `src/layout/` | 布局组件 |
-| `plugins` | `src/plugins/` | 插件配置 |
-| `types` | `src/types/` | TypeScript 类型定义 |
-| `deps` | `package.json` | 依赖更新 |
-| `ci` | `.gitlab-ci.yml` | CI/CD 配置 |
-
-> **详细映射规则参见**：[references/scope-mapping.md](references/scope-mapping.md)
-
-## 🔀 变更分析决策树
-
-使用以下决策流程判断 type：
-
-```
-1. 是否新增了功能或页面？
-   ├── 是 → feat
-   └── 否 → 继续
-
-2. 是否修复了已有功能的问题？
-   ├── 是 → fix
-   └── 否 → 继续
-
-3. 代码行为是否改变？
-   ├── 是 → refactor（优化结构）或 perf（性能优化）
-   └── 否 → 继续
-
-4. 是否只改变了代码格式？
-   ├── 是 → style
-   └── 否 → 继续
-
-5. 是否只改变了文档/注释？
-   ├── 是 → docs
-   └── 否 → chore / build / ci
-```
-
-## 🎭 复杂场景处理
-
-### 场景 1：一次变更包含多种操作（新增 + 修改 + 删除）
-
-**判断依据**：这些变更是否服务于**同一个业务目标**
-
-| 情况 | 策略 |
-|------|------|
-| 同一功能：新增组件 + 修改路由 + 删除旧组件 | ✅ **单次提交**：<br>`feat(views): [UserManage] 新增用户管理模块`<br><br>`- 新增用户列表页`<br>`- 配置相关路由`<br>`- 移除旧版组件` |
-| 无关功能：新增页面 + 修复另一个 Bug | ❌ **拆分提交**：先 `feat` 后 `fix` |
-
-### 场景 2：功能开发 + 样式修改
-
-| 情况 | 策略 |
-|------|------|
-| 样式是功能的一部分 | ✅ 归入 `feat`：`feat(views): [Profile] 新增用户头像样式` |
-| 独立的样式优化 | 🔀 拆分 `style`：`style(views): [Profile] 优化头像布局` |
-
-### 场景 3：重构 + Bug 修复
-
-| 情况 | 策略 |
-|------|------|
-| 重构过程中发现并修复的小 Bug | ✅ 归入 `refactor` |
-| 重大 Bug 修复 | 🔀 拆分为两个提交 |
-
-### 场景 4：跨多个目录的变更
-
-**优先级**：按主要变更目录选择 scope
-
-```
-示例：新增用户管理页面，涉及：
-- src/views/UserManage/index.vue（主要）
-- src/api/user.ts（API 支持）
-- src/router/index.ts（路由配置）
-
-推荐：
-feat(views): [UserManage] 新增用户管理页面
-
-- 完成页面 UI 开发
-- 集成相关 API
-- 注册路由配置
-```
-
-## ✅ 生成提交信息检查清单
-
-生成提交信息后自动检查：
-
-- [ ] **Type 正确**：是否准确反映变更性质
-- [ ] **Scope 准确**：是否匹配主要变更目录
-- [ ] **语言规范**：Subject 和 Body 必须使用**中文**
-- [ ] **模块清晰**：是否标注了具体模块名
-- [ ] **描述简洁**：首行不超过 72 字符
-- [ ] **格式规范**：冒号后有空格，方括号格式正确，Body 使用列表形式
-
-## 🚨 常见错误
-
-### ❌ 错误 1：混合不相关变更
-
-```
-feat: 新增用户页面并修复登录问题
-```
-
-✅ **正确做法**：拆分为两个提交
-```
-feat(views): [UserManage] 新增用户管理页面
-fix(views): [Login] 修复登录状态检测逻辑
-```
-
-### ❌ 错误 2：Scope 使用功能名而非目录名
-
-```
-feat(user): 新增用户列表
-```
-
-✅ **正确做法**：
-```
-feat(views): [User] 新增用户列表页面
-```
-
-### ❌ 错误 3：描述过于模糊
-
-```
-fix(api): 修复问题
-```
-
-✅ **正确做法**：
-```
-fix(api): [OrderService] 修复订单金额计算精度丢失
-```
-
-## 💡 最佳实践
-
-1. **原子化提交**：每个提交只包含一个独立的功能或修复
-2. **强制中文**：所有描述必须使用中文
-3. **模块名必须标注**：在 Subject 开头用 `[模块名]` 标识
-4. **Scope 必须匹配目录**：禁止使用业务功能名作为 Scope
-5. **详细描述**：对于复杂变更，**必须**使用 Body 列表详细说明变更点
-
-## 📝 提交信息生成流程
-
-1. **分析变更**：执行 `git status` 和 `git diff --stat` 查看变更
-2. **识别类型**：使用决策树判断 type
-3. **确定范围**：根据主要变更文件确定 scope
-4. **生成信息**：按格式生成提交信息（确保使用中文）
-5. **复核检查**：使用检查清单验证
-
----
-
-**最后更新**: 2026-02-04

package/template/.agents/skills/yss-microapp-commit/agents/openai.yaml

@@ -1,5 +0,0 @@
-version: 1
-interface:
-  display_name: "YSS Microapp Commit"
-  short_description: "微应用 Conventional Commit 提交规范"
-  default_prompt: "Use $yss-microapp-commit to generate a Conventional Commit message for a YSS micro-app change."