mindforge-cc 2.0.0-alpha.9 → 2.1.0

package/.agent/CLAUDE.md

@@ -543,3 +543,29 @@ preferences while keeping governance and quality gates intact.
 - `/mindforge:metrics`
 
 ---
+
+## SELF-BUILDING SKILLS PLATFORM (v2.0.0 — Day 13)
+
+### When to suggest /mindforge:learn
+- After a productive phase that introduced a new technology
+- When the user mentions struggling with a specific library
+- After `/mindforge:research` produces findings worth capturing as skills
+- When debug sessions uncover patterns worth remembering
+
+### Auto-capture hook
+When AUTO_CAPTURE_SKILLS=true in MINDFORGE.md:
+After every phase that passes all gates:
+  Run `bin/skills-builder/pattern-detector.js` on the phase SUMMARY files.
+  If patterns found (frequency ≥ 2): present for user approval.
+  If approved: run the full learn pipeline to create a skill.
+
+### AUDIT events for skill learning
+- skill_learned: source_type, source, skill_name, quality_score, tier, cost_usd
+- auto_capture_skipped: phase, patterns_found (0 = no patterns, N = user declined)
+- marketplace_action: action, query/skill_name, quality_score
+
+### New commands (Day 13)
+- /mindforge:learn — convert any documentation into a reusable skill
+- /mindforge:marketplace — discover and install community skills
+
+---

package/.agent/mindforge/add-backlog.md

@@ -0,0 +1,32 @@
+---
+name: mindforge:add-backlog
+description: Capture ideas in a "parking lot" to keep them out of the active phase sequence
+argument-hint: <description>
+allowed-tools:
+  - view_file
+  - write_to_file
+  - replace_file_content
+  - multi_replace_file_content
+---
+
+<objective>
+Capture an idea, task, or feature request in a "parking lot" section of the ROADMAP.md to prevent it from cluttering the active development phases.
+</objective>
+
+<execution_context>
+.claude/commands/mindforge/add-backlog.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (The description of the backlog item)
+Target File: ROADMAP.md
+State: Uses 999.x numbering scheme for backlog items.
+</context>
+
+<process>
+1. **Read ROADMAP.md**: Locate the `## Backlog` or `## Future Milestones` section.
+2. **Initialize if missing**: If no backlog section exists, create `## Backlog` at the end of the file.
+3. **Determine numbering**: Find the last `999.x` item. If none, start with `999.1`.
+4. **Append item**: Add the new backlog item with the determined number and the provided description.
+5. **Confirm**: Notify the user that the item has been parked in the backlog.
+</process>

package/.agent/mindforge/agent.md

@@ -0,0 +1,31 @@
+---
+name: mindforge:agent
+description: Spawn or invoke a specialized enterprise persona from the MindForge library
+argument-hint: "[persona-name] [prompt]"
+allowed-tools:
+  - list_dir
+  - view_file
+---
+
+<objective>
+Provide an on-demand mechanism to "spawn" any of the 13+ standardized MindForge personas. This allows the user to switch the AI assistant's context, role, and process to a specific specialized mode (e.g., Roadmapper, Security Reviewer, Analyst).
+</objective>
+
+<execution_context>
+.claude/commands/mindforge/agent.md
+</execution_context>
+
+<context>
+Personas Directory: `.mindforge/personas/`
+State: Loads the persona's XML-tagged structure into the active system context.
+</context>
+
+<process>
+1. **List Personas**: If no arguments are provided, list all available `.md` files in `.mindforge/personas/` with their name and description (parsed from YAML).
+2. **Load Persona**: If a name is provided:
+    - Locate `.mindforge/personas/[name].md`.
+    - Read the file content.
+    - Present the persona's role and success criteria to the user.
+3. **Switch Mode**: Instruct the AI (through the current session context) to adopt the role, philosophy, and process defined in the loaded file.
+4. **Initial Task**: If a prompt is provided as the second argument, immediately execute that prompt using the newly adopted persona.
+</process>

package/.agent/mindforge/do.md

@@ -0,0 +1,31 @@
+---
+name: mindforge:do
+description: Smart natural language dispatcher to route intent to the right MindForge command
+argument-hint: <text>
+allowed-tools:
+  - list_dir
+  - view_file
+---
+
+<objective>
+Provide a high-level, natural language interface for users to interact with MindForge without needing to remember specific command names. Routes user intent to the most appropriate internal command.
+</objective>
+
+<execution_context>
+.claude/commands/mindforge/do.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (The user's intent in plain English)
+Knowledge: Must be aware of all available `.claude/commands/mindforge/*.md` definitions.
+</context>
+
+<process>
+1. **Analyze input**: Parse the user's natural language request.
+2. **Match command**: Compare the intent against the descriptions and objectives of all known MindForge commands.
+3. **Execute match**:
+    - If a clear match is found, immediately pivot to that command's logic.
+    - If multiple matches are possible, ask the user for clarification.
+    - If no match is found, suggest the most relevant command or offer `/mindforge:help`.
+4. **Learn (Optional)**: If the user confirms a routing was correct, record the mapping for future intent resolution.
+</process>

package/.agent/mindforge/execute-phase.md

@@ -164,4 +164,27 @@ Write final AUDIT entry:
 
 Next step: Run /mindforge:verify-phase [N] for UAT sign-off.
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+## Step 7 — Auto-capture check (when AUTO_CAPTURE_SKILLS=true)
+
+After all gates pass and the phase is verified:
+
+```bash
+# Check if auto-capture is enabled
+CAPTURE=$(grep -m1 "^AUTO_CAPTURE_SKILLS=" MINDFORGE.md 2>/dev/null | cut -d= -f2 | tr -d ' ')
+if [ "$CAPTURE" = "true" ]; then
+  node -e "
+    const { detectPatterns, formatForPresentation } = require('./bin/skills-builder/pattern-detector');
+    detectPatterns(${PHASE_NUM}).then(result => {
+      const display = formatForPresentation(result);
+      console.log(display);
+    }).catch(err => console.error('[auto-capture] Error:', err.message));
+  "
+fi
+```
+
+If patterns are found: display the prompt and await user input.
+If user selects yes: run `/mindforge:learn --session` targeting this phase's SUMMARY files.
+If user selects no: write AUDIT entry `auto_capture_skipped` and continue.
+If no patterns found: exit silently (no noise in the output).
 ```

package/.agent/mindforge/install-skill.md

@@ -1,15 +1,24 @@
-# MindForge — Install Skill Command
-# Usage: /mindforge:install-skill [skill-name|package-name] [--tier 1|2|3] [--registry URL]
-
 Follow the full installation protocol from `.mindforge/distribution/registry-client.md`.
 
 Steps:
-1. Resolve package name from skill name
-2. Check if already installed (skip if same version, offer upgrade if newer)
-3. Fetch from registry (npm or private if --registry specified)
-4. Validate the skill (Level 1 + Level 2 from skill-validator.md)
-5. Run injection guard check
-6. Install to tier directory (default: Tier 2 org skill)
-7. Register in MANIFEST.md
-8. Write AUDIT entry
+1. Resolve package name from skill name.
+2. Check if already installed (skip if same version, offer upgrade if newer).
+3. Fetch from registry (npm or private if --registry specified).
+4. Validate the skill:
+   ```bash
+   node bin/mindforge-cli.js validate-skill ./SKILL.md
+   ```
+5. Run injection guard check (handled by validator).
+6. Install to tier directory:
+   ```bash
+   node bin/mindforge-cli.js install-skill [skill-name] --tier [1|2|3]
+   ```
+7. Register in MANIFEST.md:
+   ```bash
+   node bin/mindforge-cli.js register-skill [skill-name] [version] [tier]
+   ```
+8. Write AUDIT entry:
+   ```bash
+   node bin/mindforge-cli.js audit-skill [skill-name] [version] [tier]
+   ```
 9. Confirm: "Run /mindforge:skills validate to verify installation"

package/.agent/mindforge/learn.md

@@ -0,0 +1,142 @@
+# MindForge v2 — Learn Command
+# Usage: /mindforge:learn [url|path|--session|npm:package] [--name skill-name] [--tier project|org|core]
+# Version: v2.0.0-alpha.6
+
+## Purpose
+Convert any knowledge source into a reusable, validated, committed MindForge SKILL.md.
+Feed Claude your documentation and it writes down what it learned — for every future session.
+
+## The insight
+Every developer on your team already knows how Prisma works, how your internal API
+conventions are structured, how your CI pipeline behaves. That knowledge lives in their
+heads and in documentation. `/mindforge:learn` captures it permanently as skills that
+load automatically whenever relevant work begins.
+
+## Usage examples
+
+### Learn from external documentation
+```
+/mindforge:learn https://docs.prisma.io/concepts/components/prisma-schema
+/mindforge:learn https://stripe.com/docs/webhooks
+/mindforge:learn https://docs.aws.amazon.com/lambda/latest/dg/nodejs-handler.html
+```
+→ Fetches the page (with SSRF protection)
+→ Uses Gemini 2.5 Pro (1M context) for large docs, claude-sonnet-4-6 for smaller ones
+→ Extracts 10 patterns + 15-25 trigger keywords
+→ Writes SKILL.md + scores it + presents for approval
+
+### Learn from local documentation
+```
+/mindforge:learn ./docs/api-conventions.md
+/mindforge:learn ./docs/internal/
+/mindforge:learn ./CONTRIBUTING.md
+```
+→ Reads local files directly (no model call for reading, only for analysis)
+→ Perfect for: internal API docs, team conventions, onboarding guides
+
+### Learn from npm package docs
+```
+/mindforge:learn npm:zod
+/mindforge:learn npm:drizzle-orm
+/mindforge:learn npm:@tanstack/react-query
+```
+→ Fetches README from npm registry
+→ Extracts patterns from the package documentation
+
+### Learn from current session
+```
+/mindforge:learn --session
+```
+→ Analyses SUMMARY files from the most recent phase
+→ Finds patterns that appeared across 2+ tasks
+→ Generates up to 3 skills from what was learned (focused: quality over quantity)
+→ Does NOT repeat patterns already in the knowledge base
+
+## Flags
+
+### --name [skill-name]
+Override the auto-generated skill name (kebab-case).
+Default: inferred from the URL domain/path or file name.
+Example: `/mindforge:learn ./docs/prisma-patterns.md --name prisma-advanced`
+
+### --tier [project|org|core]
+Where to install the skill (default: project).
+- project: only loads in this project (T3)
+- org: loads in all projects using this org config (T2)
+- core: loads everywhere (T1 — use sparingly)
+
+### --model [model-id]
+Override the model used for analysis.
+Default: RESEARCH_MODEL for large content (>50K chars), EXECUTOR_MODEL for small.
+
+## Output format
+
+```
+📚 Learning from: https://docs.prisma.io/...
+
+  🔍 Fetching content...            done (148K chars)
+  🧠 Extracting patterns (gemini-2.5-pro)...
+  Step 1/3 — Extracting patterns... done (10 patterns)
+  Step 2/3 — Generating triggers... done (22 triggers)
+  Step 3/3 — Writing SKILL.md...    done
+
+📊 Skill Quality Score: 84/100 (Good — can register + publish)
+  trigger_coverage   : 26/30   ✅
+  mandatory_actions  : 21/25   ✅
+  code_examples      : 17/20   ✅
+  self_check         : 12/15   ✅
+  injection_safe     : 10/10   ✅
+  no_placeholders    : 9/10    ✅
+  version_history    : 8/10    ⚠️
+
+Preview (top 3 patterns):
+  1. [CRITICAL] Always define explicit cascade behaviour
+     "Set onDelete on every @relation — never rely on database defaults"
+  2. [HIGH] Use compound indexes for cursor pagination
+     "Always index (createdAt, id) together for reliable cursor pagination"
+  3. [HIGH] Never use String for UUID fields in Prisma schema
+     "Use @id @default(uuid()) with the String type — Prisma handles this"
+
+Triggers (22): prisma schema, schema.prisma, @relation, prisma migrate,
+               @id @default, prisma.findMany, prisma generate, model definition...
+
+Skill file: .mindforge/skills/prisma-schema/SKILL.md
+
+[ y ] Register in project tier and commit
+[ n ] Discard
+[ e ] Edit SKILL.md before registering
+[ p ] Register AND publish to community marketplace (score ≥ 80 ✅)
+```
+
+## After registration
+
+```
+✅ Skill registered: prisma-schema (T3 Project)
+
+  Will auto-load when tasks contain:
+    "prisma schema", "schema.prisma", "@relation", "prisma migrate"...
+
+  Committed: feat(skills): learn prisma-schema from docs.prisma.io
+
+  Next: /mindforge:skills info prisma-schema
+```
+
+## Integration with auto-capture
+When `AUTO_CAPTURE_SKILLS=true` in MINDFORGE.md:
+`/mindforge:learn --session` is called automatically after each phase completion.
+The prompt is shown; if no patterns found, it exits silently (no noise).
+
+## AUDIT entry
+```json
+{
+  "event": "skill_learned",
+  "source_type": "url|local|session|npm",
+  "source": "[url or path]",
+  "skill_name": "prisma-schema",
+  "quality_score": 84,
+  "pattern_count": 10,
+  "trigger_count": 22,
+  "tier": "project",
+  "cost_usd": 0.31
+}
+```

package/.agent/mindforge/marketplace.md

@@ -0,0 +1,120 @@
+# MindForge v2 — Marketplace Command
+# Usage: /mindforge:marketplace [search|featured|trending|install|publish]
+# Version: v2.0.0-alpha.6
+
+## Purpose
+Discover, evaluate, and install community-published MindForge skills from the
+marketplace — a curated layer on top of the npm registry.
+
+The marketplace is the shortcut: instead of learning from documentation yourself,
+install skills that the community has already created, validated, and battle-tested.
+
+## Sub-commands
+
+### search [query]
+Find skills relevant to your tech stack or domain.
+```
+/mindforge:marketplace search "prisma"
+/mindforge:marketplace search "stripe payment processing"
+/mindforge:marketplace search "HIPAA compliance"
+/mindforge:marketplace search "graphql api"
+```
+
+Output:
+```
+🔍 Marketplace search: "prisma" (6 results)
+
+  1. prisma-advanced (v1.2.3)
+     Advanced Prisma patterns: relations, migrations, performance, cursor pagination
+     847 installs this week
+
+  2. prisma-schema (v1.0.1)
+     Prisma schema design: models, relations, enums, cascade rules
+     234 installs this week
+
+  3. prisma-testing (v1.0.0)
+     Testing Prisma with Jest: database seeding, teardown, transaction rollback
+     156 installs this week
+
+Install: /mindforge:marketplace install prisma-advanced
+```
+
+### featured
+Show curated featured skills by category.
+```
+/mindforge:marketplace featured
+```
+
+Output:
+```
+🏪 MindForge Community Skills — Featured
+
+  Database:
+    db-postgres-advanced v2.1.0  — Advanced PostgreSQL patterns, indexes, partitioning
+    db-prisma-advanced   v1.2.0  — Prisma relations, migrations, query optimisation
+    db-drizzle           v1.0.0  — Drizzle ORM type-safe patterns
+
+  API:
+    api-graphql v1.4.0  — GraphQL schema, resolvers, N+1 prevention
+    api-rest    v2.0.0  — REST API design, versioning, error schemas
+
+  Compliance:
+    fintech-pci-compliance  v1.1.0 — PCI DSS Level 1 safeguards
+    healthtech-hipaa        v1.0.1 — HIPAA Security Rule for PHI
+    [more...]
+```
+
+### trending
+Show most-installed skills this month.
+```
+/mindforge:marketplace trending
+```
+
+### install [name] [--tier project|org]
+Install a marketplace skill.
+```
+/mindforge:marketplace install prisma-advanced
+/mindforge:marketplace install mindforge-skill-api-graphql --tier org
+/mindforge:marketplace install fintech-pci-compliance --tier project
+```
+
+Short names work (without `mindforge-skill-` prefix).
+Delegates to `/mindforge:install-skill` for actual installation.
+Shows quality score and session_quality_lift before installing.
+
+### publish [skill-dir]
+Publish a skill to the community marketplace.
+```
+/mindforge:marketplace publish .mindforge/skills/my-skill/
+```
+
+Requirements:
+- Quality score ≥ 80/100
+- No injection patterns
+- Has complete version history
+- Has author contact (GitHub issues URL)
+
+## Skill quality display format
+
+```
+📊 Skill: prisma-advanced v1.2.3
+   Quality score: 94/100 (Excellent)
+   ★★★★★ Session quality lift: +8.2 points (over 1,247 sessions)
+   847 installs/week | Published by: @prisma-community
+
+   Top trigger keywords: "prisma schema", "@relation", "prisma migrate",
+                          "prisma generate", "onDelete", "cursor pagination"
+
+   [Install] [Preview SKILL.md] [View on npm]
+```
+
+## AUDIT entry
+```json
+{
+  "event": "marketplace_action",
+  "action": "search|install|publish",
+  "query": "[search query if search]",
+  "skill_name": "[name if install/publish]",
+  "quality_score": 94
+}
+```

package/.agent/mindforge/new-runtime.md

@@ -0,0 +1,19 @@
+# /mindforge:new-runtime
+
+Scaffold support for a new AI coding runtime.
+
+## Usage
+
+/mindforge:new-runtime [name]
+
+## Action
+
+1.  Identify target runtime's entry file format (e.g. .myrules, instructions.md)
+2.  Scaffold the required directories in both global and local scopes
+3.  Add a new entry to the RUNTIMES configuration in `bin/installer-core.js`
+4.  Generate first-run instructions for the new runtime
+
+## Examples
+
+/mindforge:new-runtime void-editor
+/mindforge:new-runtime zed-ai

package/.agent/mindforge/note.md

@@ -0,0 +1,35 @@
+---
+name: mindforge:note
+description: Capture an idea, task, or issue that surfaces during a session as a quick note for later
+argument-hint: <text> [list|promote N]
+allowed-tools:
+  - list_dir
+  - view_file
+  - write_to_file
+  - multi_replace_file_content
+---
+
+<objective>
+Provide a zero-friction way to capture ephemeral thoughts, bugs, or todos during an active session without interrupting the current flow, with the ability to later promote them to official tasks.
+</objective>
+
+<execution_context>
+.claude/commands/mindforge/note.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (The note text or subcommand like `list` or `promote`)
+Storage: .planning/notes/
+Target for Promotion: ROADMAP.md or STATE.md
+</context>
+
+<process>
+1. **Route Subcommand**:
+    - If `list`: Read all files in `.planning/notes/` and present them.
+    - If `promote <N>`: Read note N, add it to current phase/milestone in STATE.md or ROADMAP.md, then move the note to `.planning/notes/archived/`.
+    - Else (default): Capture the text.
+2. **Capture Flow**:
+    - Ensure `.planning/notes/` directory.
+    - Create a file `note_[timestamp].md` with the content.
+3. **Confirm**: Quick confirmation of capture or promotion result.
+</process>

package/.agent/mindforge/plant-seed.md

@@ -0,0 +1,31 @@
+---
+name: mindforge:plant-seed
+description: Capture speculative ideas with triggers that surface automatically when relevant
+argument-hint: <idea>
+allowed-tools:
+  - list_dir
+  - write_to_file
+  - view_file
+---
+
+<objective>
+Capture speculative or long-term ideas (seeds) and store them in a way that they can be automatically resurfaced when a relevant future milestone or phase is started.
+</objective>
+
+<execution_context>
+.claude/commands/mindforge/plant-seed.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (The speculative idea)
+Storage: .planning/seeds/
+Trigger mechanism: Files in this directory are checked during `init-project` or `milestone` creation.
+</context>
+
+<process>
+1. **Ensure storage**: Verify `.planning/seeds/` exists; create if not.
+2. **Generate filename**: Create a slugified filename based on the idea or a timestamp.
+3. **Write seed**: Create a markdown file with the idea, any inferred triggers (tags/keywords), and the current timestamp.
+4. **Link to system**: Add a note to the master seed index if one exists.
+5. **Confirm**: Let the user know the seed has been planted and what might trigger its resurrection.
+</process>

package/.agent/mindforge/remember.md

@@ -4,10 +4,22 @@ Manage the MindForge long-term memory (knowledge graph).
 
 ## Usage
 
-- `/mindforge:remember --add "Your knowledge content"`: Manually add an entry.
-- `/mindforge:remember --search "your query"`: Search the knowledge base.
-- `/mindforge:remember --stats`: View memory statistics.
-- `/mindforge:remember --promote "id"`: Promote a project entry to global memory.
+- Add an entry:
+  ```bash
+  node bin/mindforge-cli.js remember --add "Your knowledge" --topic "Title"
+  ```
+- Search memories:
+  ```bash
+  node bin/mindforge-cli.js remember --search "query" --global
+  ```
+- View statistics:
+  ```bash
+  node bin/mindforge-cli.js remember --stats
+  ```
+- Promote to global:
+  ```bash
+  node bin/mindforge-cli.js remember --promote "id"
+  ```
 
 ## Description
 

package/.agent/mindforge/review-backlog.md

@@ -0,0 +1,34 @@
+---
+name: mindforge:review-backlog
+description: Review and promote backlog items to the active phase sequence
+argument-hint: [optional filters]
+allowed-tools:
+  - view_file
+  - write_to_file
+  - replace_file_content
+  - multi_replace_file_content
+---
+
+<objective>
+Review items currently parked in the ROADMAP.md backlog and facilitate their promotion to the active development plan.
+</objective>
+
+<execution_context>
+.claude/commands/mindforge/review-backlog.md
+</execution_context>
+
+<context>
+Target File: ROADMAP.md, STATE.md
+State: Resolves the next available phase number from STATE.md for promotion.
+</context>
+
+<process>
+1. **Read ROADMAP.md**: Extract all items under the `## Backlog` section (999.x).
+2. **Present to User**: List the backlog items and ask which one(s) should be promoted.
+3. **Determine Promotion Slot**: Read STATE.md to find the next sequential phase number.
+4. **Promote Item**:
+    - Move the item from the backlog to the active milestone list.
+    - Renumber the item to the next available phase number.
+5. **Update STATE.md**: Add the new phase to STATE.md in `unplanned` or `planned` status as appropriate.
+6. **Confirm**: Summarize the promotion to the user.
+</process>

package/.agent/mindforge/session-report.md

@@ -0,0 +1,39 @@
+---
+name: mindforge:session-report
+description: Generate a post-session summary document capturing work performed and resource usage
+argument-hint: none
+allowed-tools:
+  - run_command
+  - view_file
+  - write_to_file
+  - list_dir
+---
+
+<objective>
+Generate a comprehensive summary of an active coding session, providing a clear trail of work for stakeholders and a diagnostic record of resource usage (tokens, time, etc.).
+</objective>
+
+<execution_context>
+.claude/commands/mindforge/session-report.md
+</execution_context>
+
+<context>
+Storage: .planning/reports/
+Data sources: Git logs, terminal history, `STATE.md`, and session memory.
+</context>
+
+<process>
+1. **Gather Data**:
+    - Get recent git commits and diff summaries.
+    - Read the current `STATE.md` for phase/plan status updates.
+    - Extract key decisions or findings from the session.
+2. **Profile Resources**:
+    - Estimate token usage if possible.
+    - Calculate session duration.
+3. **Draft Report**: Create `SESSION_REPORT_[timestamp].md` containing:
+    - Summary of Work Performed
+    - Outcomes achieved (Plans "completed")
+    - Key Decisions
+    - Resource Usage Profile
+4. **Confirm**: Notify the user and provide a link to the report.
+</process>

package/.agent/mindforge/ui-phase.md

@@ -0,0 +1,34 @@
+---
+name: mindforge:ui-phase
+description: Generate a UI Design Contract (UI-SPEC.md) for the current phase
+argument-hint: [N]
+allowed-tools:
+  - view_file
+  - write_to_file
+  - list_dir
+---
+
+<objective>
+Generate a detailed UI design contract (UI-SPEC.md) for a frontend development phase to ensure consistent spacing, typography, color palettes, and accessibility standards before implementation.
+</objective>
+
+<execution_context>
+.claude/commands/mindforge/ui-phase.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (The phase number [N], optional)
+Configuration: MINDFORGE.md `UI_PHASE_ACCESSIBILITY_STANDARD`
+State: Resolves the phase from STATE.md if N is not provided.
+</context>
+
+<process>
+1. **Identify Phase**: Get the current or targeted phase number.
+2. **Read Inputs**: Read `REQUIREMENTS.md` and `DESIGN_SYSTEM.md`.
+3. **Generate UI-SPEC.md**:
+    - Define component-level spacing and layout for the phase.
+    - Specify required colors and typography from the design system.
+    - List accessibility requirements (WCAG level).
+4. **Finalize**: Write `UI-SPEC.md` to the phase's planning directory or the root `.planning/`.
+5. **Confirm**: Provide a link to the user for review.
+</process>