claude-code-workflow 6.2.3 → 6.2.5

package/.claude/skills/command-guide/reference/commands/memory/style-skill-memory.md

@@ -1,396 +0,0 @@
----
-name: style-skill-memory
-description: Generate SKILL memory package from style reference for easy loading and consistent design system usage
-argument-hint: "[package-name] [--regenerate]"
-allowed-tools: Bash,Read,Write,TodoWrite
-auto-continue: true
----
-
-# Memory: Style SKILL Memory Generator
-
-## Overview
-
-**Purpose**: Convert style reference package into SKILL memory for easy loading and context management.
-
-**Input**: Style reference package at `.workflow/reference_style/{package-name}/`
-
-**Output**: SKILL memory index at `.claude/skills/style-{package-name}/SKILL.md`
-
-**Use Case**: Load design system context when working with UI components, analyzing design patterns, or implementing style guidelines.
-
-**Key Features**:
-- Extracts primary design references (colors, typography, spacing, etc.)
-- Provides dynamic adjustment guidelines for design tokens
-- Includes prerequisites and tooling requirements (browsers, PostCSS, dark mode)
-- Progressive loading structure for efficient token usage
-- Complete implementation examples with React components
-- Interactive preview showcase
-
----
-
-## Quick Reference
-
-### Command Syntax
-
-```bash
-/memory:style-skill-memory [package-name] [--regenerate]
-
-# Arguments
-package-name    Style reference package name (required)
---regenerate    Force regenerate SKILL.md even if it exists (optional)
-```
-
-### Usage Examples
-
-```bash
-# Generate SKILL memory for package
-/memory:style-skill-memory main-app-style-v1
-
-# Regenerate SKILL memory
-/memory:style-skill-memory main-app-style-v1 --regenerate
-
-# Package name from current directory or default
-/memory:style-skill-memory
-```
-
-### Key Variables
-
-**Input Variables**:
-- `PACKAGE_NAME`: Style reference package name
-- `PACKAGE_DIR`: `.workflow/reference_style/${package_name}`
-- `SKILL_DIR`: `.claude/skills/style-${package_name}`
-- `REGENERATE`: `true` if --regenerate flag, `false` otherwise
-
-**Data Sources** (Phase 2):
-- `DESIGN_TOKENS_DATA`: Complete design-tokens.json content (from Read)
-- `LAYOUT_TEMPLATES_DATA`: Complete layout-templates.json content (from Read)
-- `ANIMATION_TOKENS_DATA`: Complete animation-tokens.json content (from Read, if exists)
-
-**Metadata** (Phase 2):
-- `COMPONENT_COUNT`: Total components
-- `UNIVERSAL_COUNT`: Universal components count
-- `SPECIALIZED_COUNT`: Specialized components count
-- `UNIVERSAL_COMPONENTS`: Universal component names (first 5)
-- `HAS_ANIMATIONS`: Whether animation-tokens.json exists
-
-**Analysis Output** (`DESIGN_ANALYSIS` - Phase 2):
-- `has_colors`: Colors exist
-- `color_semantic`: Has semantic naming (primary/secondary/accent)
-- `uses_oklch`: Uses modern color spaces (oklch, lab, etc.)
-- `has_dark_mode`: Has separate light/dark mode color tokens
-- `spacing_pattern`: Pattern type ("linear", "geometric", "custom")
-- `spacing_scale`: Actual scale values (e.g., [4, 8, 16, 32, 64])
-- `has_typography`: Typography system exists
-- `typography_hierarchy`: Has size scale for hierarchy
-- `uses_calc`: Uses calc() expressions in token values
-- `has_radius`: Border radius exists
-- `radius_style`: Style characteristic ("sharp" <4px, "moderate" 4-8px, "rounded" >8px)
-- `has_shadows`: Shadow system exists
-- `shadow_pattern`: Elevation naming pattern
-- `has_animations`: Animation tokens exist
-- `animation_range`: Duration range (fast to slow)
-- `easing_variety`: Types of easing functions
-
-### Common Errors
-
-| Error | Cause | Resolution |
-|-------|-------|------------|
-| Package not found | Invalid package name or doesn't exist | Run `/workflow:ui-design:codify-style` first |
-| SKILL already exists | SKILL.md already generated | Use `--regenerate` flag |
-| Missing layout-templates.json | Incomplete package | Verify package integrity, re-run codify-style |
-| Invalid JSON format | Corrupted package files | Regenerate package with codify-style |
-
----
-
-## Execution Process
-
-### Phase 1: Validate Package
-
-**TodoWrite** (First Action):
-```json
-[
-  {
-    "content": "Validate package exists and check SKILL status",
-    "activeForm": "Validating package and SKILL status",
-    "status": "in_progress"
-  },
-  {
-    "content": "Read package data and analyze design system",
-    "activeForm": "Reading package data and analyzing design system",
-    "status": "pending"
-  },
-  {
-    "content": "Generate SKILL.md with design principles and token values",
-    "activeForm": "Generating SKILL.md with design principles and token values",
-    "status": "pending"
-  }
-]
-```
-
-**Step 1: Parse Package Name**
-
-```bash
-# Get package name from argument or auto-detect
-bash(echo "${package_name}" || basename "$(pwd)" | sed 's/^style-//')
-```
-
-**Step 2: Validate Package Exists**
-
-```bash
-bash(test -d .workflow/reference_style/${package_name} && echo "exists" || echo "missing")
-```
-
-**Error Handling**:
-```javascript
-if (package_not_exists) {
-  error("ERROR: Style reference package not found: ${package_name}")
-  error("HINT: Run '/workflow:ui-design:codify-style' first to create package")
-  error("Available packages:")
-  bash(ls -1 .workflow/reference_style/ 2>/dev/null || echo "  (none)")
-  exit(1)
-}
-```
-
-**Step 3: Check SKILL Already Exists**
-
-```bash
-bash(test -f .claude/skills/style-${package_name}/SKILL.md && echo "exists" || echo "missing")
-```
-
-**Decision Logic**:
-```javascript
-if (skill_exists && !regenerate_flag) {
-  echo("SKILL memory already exists for: ${package_name}")
-  echo("Use --regenerate to force regeneration")
-  exit(0)
-}
-
-if (regenerate_flag && skill_exists) {
-  echo("Regenerating SKILL memory for: ${package_name}")
-}
-```
-
-**TodoWrite Update**: Mark "Validate" as completed, "Read package data" as in_progress
-
----
-
-### Phase 2: Read Package Data & Analyze Design System
-
-**Step 1: Read All JSON Files**
-
-```bash
-# Read layout templates
-Read(file_path=".workflow/reference_style/${package_name}/layout-templates.json")
-
-# Read design tokens
-Read(file_path=".workflow/reference_style/${package_name}/design-tokens.json")
-
-# Read animation tokens (if exists)
-bash(test -f .workflow/reference_style/${package_name}/animation-tokens.json && echo "exists" || echo "missing")
-Read(file_path=".workflow/reference_style/${package_name}/animation-tokens.json")  # if exists
-```
-
-**Step 2: Extract Metadata for Description**
-
-```bash
-# Count components and classify by type
-bash(jq '.layout_templates | length' layout-templates.json)
-bash(jq '[.layout_templates[] | select(.component_type == "universal")] | length' layout-templates.json)
-bash(jq '[.layout_templates[] | select(.component_type == "specialized")] | length' layout-templates.json)
-bash(jq -r '.layout_templates | to_entries[] | select(.value.component_type == "universal") | .key' layout-templates.json | head -5)
-```
-
-Store results in metadata variables (see [Key Variables](#key-variables))
-
-**Step 3: Analyze Design System for Dynamic Principles**
-
-Analyze design-tokens.json to extract characteristics and patterns:
-
-```bash
-# Color system characteristics
-bash(jq '.colors | keys' design-tokens.json)
-bash(jq '.colors | to_entries[0:2] | map(.value)' design-tokens.json)
-# Check for modern color spaces
-bash(jq '.colors | to_entries[] | .value | test("oklch|lab|lch")' design-tokens.json)
-# Check for dark mode variants
-bash(jq '.colors | keys | map(select(contains("dark") or contains("light")))' design-tokens.json)
-# → Store: has_colors, color_semantic, uses_oklch, has_dark_mode
-
-# Spacing pattern detection
-bash(jq '.spacing | to_entries | map(.value) | map(gsub("[^0-9.]"; "") | tonumber)' design-tokens.json)
-# Analyze pattern: linear (4-8-12-16) vs geometric (4-8-16-32) vs custom
-# → Store: spacing_pattern, spacing_scale
-
-# Typography characteristics
-bash(jq '.typography | keys | map(select(contains("family") or contains("weight")))' design-tokens.json)
-bash(jq '.typography | to_entries | map(select(.key | contains("size"))) | .[].value' design-tokens.json)
-# Check for calc() usage
-bash(jq '. | tostring | test("calc\\(")' design-tokens.json)
-# → Store: has_typography, typography_hierarchy, uses_calc
-
-# Border radius style
-bash(jq '.border_radius | to_entries | map(.value)' design-tokens.json)
-# Check range: small (sharp <4px) vs moderate (4-8px) vs large (rounded >8px)
-# → Store: has_radius, radius_style
-
-# Shadow characteristics
-bash(jq '.shadows | keys' design-tokens.json)
-bash(jq '.shadows | to_entries[0].value' design-tokens.json)
-# → Store: has_shadows, shadow_pattern
-
-# Animations (if available)
-bash(jq '.duration | to_entries | map(.value)' animation-tokens.json)
-bash(jq '.easing | keys' animation-tokens.json)
-# → Store: has_animations, animation_range, easing_variety
-```
-
-Store analysis results in `DESIGN_ANALYSIS` (see [Key Variables](#key-variables))
-
-**Note**: Analysis focuses on characteristics and patterns, not counts. Include technical feature detection (oklch, calc, dark mode) for Prerequisites section.
-
-**TodoWrite Update**: Mark "Read package data" as completed, "Generate SKILL.md" as in_progress
-
----
-
-### Phase 3: Generate SKILL.md
-
-**Step 1: Create SKILL Directory**
-
-```bash
-bash(mkdir -p .claude/skills/style-${package_name})
-```
-
-**Step 2: Generate Intelligent Description**
-
-**Format**:
-```
-{package_name} project-independent design system with {universal_count} universal layout templates and interactive preview (located at .workflow/reference_style/{package_name}). Load when working with reusable UI components, design tokens, layout patterns, or implementing visual consistency. Excludes {specialized_count} project-specific components.
-```
-
-**Step 3: Load and Process SKILL.md Template**
-
-**⚠️ CRITICAL - Execute First**:
-```bash
-bash(cat ~/.claude/workflows/cli-templates/memory/style-skill-memory/skill-md-template.md)
-```
-
-**Template Processing**:
-1. **Replace variables**: Substitute all `{variable}` placeholders with actual values from Phase 2
-2. **Generate dynamic sections**:
-   - **Prerequisites & Tooling**: Generate based on `DESIGN_ANALYSIS` technical features (oklch, calc, dark mode)
-   - **Design Principles**: Generate based on `DESIGN_ANALYSIS` characteristics
-   - **Complete Implementation Example**: Include React component example with token adaptation
-   - **Design Token Values**: Iterate `DESIGN_TOKENS_DATA`, `ANIMATION_TOKENS_DATA` and display all key-value pairs with DEFAULT annotations
-3. **Write to file**: Use Write tool to save to `.claude/skills/style-{package_name}/SKILL.md`
-
-**Variable Replacement Map**:
-- `{package_name}` → PACKAGE_NAME
-- `{intelligent_description}` → Generated description from Step 2
-- `{component_count}` → COMPONENT_COUNT
-- `{universal_count}` → UNIVERSAL_COUNT
-- `{specialized_count}` → SPECIALIZED_COUNT
-- `{universal_components_list}` → UNIVERSAL_COMPONENTS (comma-separated)
-- `{has_animations}` → HAS_ANIMATIONS
-
-**Dynamic Content Generation**:
-
-See template file for complete structure. Key dynamic sections:
-
-1. **Prerequisites & Tooling** (based on DESIGN_ANALYSIS technical features):
-   - IF uses_oklch → Include PostCSS plugin requirement (`postcss-oklab-function`)
-   - IF uses_calc → Include preprocessor requirement for calc() expressions
-   - IF has_dark_mode → Include dark mode implementation mechanism (class or media query)
-   - ALWAYS include browser support, jq installation, and local server setup
-
-2. **Design Principles** (based on DESIGN_ANALYSIS):
-   - IF has_colors → Include "Color System" principle with semantic pattern
-   - IF spacing_pattern detected → Include "Spatial Rhythm" with unified scale description (actual token values)
-   - IF has_typography_hierarchy → Include "Typographic System" with scale examples
-   - IF has_radius → Include "Shape Language" with style characteristic
-   - IF has_shadows → Include "Depth & Elevation" with elevation pattern
-   - IF has_animations → Include "Motion & Timing" with duration range
-   - ALWAYS include "Accessibility First" principle
-
-3. **Design Token Values** (iterate from read data):
-   - Colors: Iterate `DESIGN_TOKENS_DATA.colors`
-   - Typography: Iterate `DESIGN_TOKENS_DATA.typography`
-   - Spacing: Iterate `DESIGN_TOKENS_DATA.spacing`
-   - Border Radius: Iterate `DESIGN_TOKENS_DATA.border_radius` with calc() explanations
-   - Shadows: Iterate `DESIGN_TOKENS_DATA.shadows` with DEFAULT token annotations
-   - Animations (if available): Iterate `ANIMATION_TOKENS_DATA.duration` and `ANIMATION_TOKENS_DATA.easing`
-
-**Step 4: Verify SKILL.md Created**
-
-```bash
-bash(test -f .claude/skills/style-${package_name}/SKILL.md && echo "success" || echo "failed")
-```
-
-**TodoWrite Update**: Mark all todos as completed
-
----
-
-### Completion Message
-
-Display a simple completion message with key information:
-
-```
-✅ SKILL memory generated for style package: {package_name}
-
-📁 Location: .claude/skills/style-{package_name}/SKILL.md
-
-📊 Package Summary:
-   - {component_count} components ({universal_count} universal, {specialized_count} specialized)
-   - Design tokens: colors, typography, spacing, shadows{animations_note}
-
-💡 Usage: /memory:load-skill-memory style-{package_name} "your task description"
-```
-
-Variables: `{package_name}`, `{component_count}`, `{universal_count}`, `{specialized_count}`, `{animations_note}` (", animations" if exists)
-
----
-
-## Implementation Details
-
-### Critical Rules
-
-1. **Check Before Generate**: Verify package exists before attempting SKILL generation
-2. **Respect Existing SKILL**: Don't overwrite unless --regenerate flag provided
-3. **Load Templates via cat**: Use `cat ~/.claude/workflows/cli-templates/memory/style-skill-memory/{template}` to load templates
-4. **Variable Substitution**: Replace all `{variable}` placeholders with actual values
-5. **Technical Feature Detection**: Analyze tokens for modern features (oklch, calc, dark mode) and generate appropriate Prerequisites section
-6. **Dynamic Content Generation**: Generate sections based on DESIGN_ANALYSIS characteristics
-7. **Unified Spacing Scale**: Use actual token values as primary scale reference, avoid contradictory pattern descriptions
-8. **Direct Iteration**: Iterate data structures (DESIGN_TOKENS_DATA, etc.) for token values
-9. **Annotate Special Tokens**: Add comments for DEFAULT tokens and calc() expressions
-10. **Embed jq Commands**: Include bash/jq commands in SKILL.md for dynamic loading
-11. **Progressive Loading**: Include all 3 levels (0-2) with specific jq commands
-12. **Complete Examples**: Include end-to-end implementation examples (React components)
-13. **Intelligent Description**: Extract component count and key features from metadata
-14. **Emphasize Flexibility**: Strongly warn against rigid copying - values are references for creative adaptation
-
-### Template Files Location
-
-
-```
-Phase 1: Validate
-  ├─ Parse package_name
-  ├─ Check PACKAGE_DIR exists
-  └─ Check SKILL_DIR exists (skip if exists and no --regenerate)
-
-Phase 2: Read & Analyze
-  ├─ Read design-tokens.json → DESIGN_TOKENS_DATA
-  ├─ Read layout-templates.json → LAYOUT_TEMPLATES_DATA
-  ├─ Read animation-tokens.json → ANIMATION_TOKENS_DATA (if exists)
-  ├─ Extract Metadata → COMPONENT_COUNT, UNIVERSAL_COUNT, etc.
-  └─ Analyze Design System → DESIGN_ANALYSIS (characteristics)
-
-Phase 3: Generate
-  ├─ Create SKILL directory
-  ├─ Generate intelligent description
-  ├─ Load SKILL.md template (cat command)
-  ├─ Replace variables and generate dynamic content
-  ├─ Write SKILL.md
-  ├─ Verify creation
-  ├─ Load completion message template (cat command)
-  └─ Display completion message
-```

package/.claude/skills/command-guide/reference/commands/memory/tech-research.md

@@ -1,314 +0,0 @@
----
-name: tech-research
-description: "3-phase orchestrator: extract tech stack → Exa research → generate path-conditional rules (auto-loaded by Claude Code)"
-argument-hint: "[session-id | tech-stack-name] [--regenerate] [--tool <gemini|qwen>]"
-allowed-tools: SlashCommand(*), TodoWrite(*), Bash(*), Read(*), Write(*), Task(*)
----
-
-# Tech Stack Rules Generator
-
-## Overview
-
-**Purpose**: Generate multi-layered, path-conditional rules that Claude Code automatically loads based on file context.
-
-**Key Difference from SKILL Memory**:
-- **SKILL**: Manual loading via `Skill(command: "tech-name")`
-- **Rules**: Automatic loading when working with matching file paths
-
-**Output Structure**:
-```
-.claude/rules/tech/{tech-stack}/
-├── core.md           # paths: **/*.{ext} - Core principles
-├── patterns.md       # paths: src/**/*.{ext} - Implementation patterns
-├── testing.md        # paths: **/*.{test,spec}.{ext} - Testing rules
-├── config.md         # paths: *.config.* - Configuration rules
-├── api.md            # paths: **/api/**/* - API rules (backend only)
-├── components.md     # paths: **/components/**/* - Component rules (frontend only)
-└── metadata.json     # Generation metadata
-```
-
-**Templates Location**: `~/.claude/workflows/cli-templates/prompts/rules/`
-
----
-
-## Core Rules
-
-1. **Start Immediately**: First action is TodoWrite initialization
-2. **Path-Conditional Output**: Every rule file includes `paths` frontmatter
-3. **Template-Driven**: Agent reads templates before generating content
-4. **Agent Produces Files**: Agent writes all rule files directly
-5. **No Manual Loading**: Rules auto-activate when Claude works with matching files
-
----
-
-## 3-Phase Execution
-
-### Phase 1: Prepare Context & Detect Tech Stack
-
-**Goal**: Detect input mode, extract tech stack info, determine file extensions
-
-**Input Mode Detection**:
-```bash
-input="$1"
-
-if [[ "$input" == WFS-* ]]; then
-  MODE="session"
-  SESSION_ID="$input"
-  # Read workflow-session.json to extract tech stack
-else
-  MODE="direct"
-  TECH_STACK_NAME="$input"
-fi
-```
-
-**Tech Stack Analysis**:
-```javascript
-// Decompose composite tech stacks
-// "typescript-react-nextjs" → ["typescript", "react", "nextjs"]
-
-const TECH_EXTENSIONS = {
-  "typescript": "{ts,tsx}",
-  "javascript": "{js,jsx}",
-  "python": "py",
-  "rust": "rs",
-  "go": "go",
-  "java": "java",
-  "csharp": "cs",
-  "ruby": "rb",
-  "php": "php"
-};
-
-const FRAMEWORK_TYPE = {
-  "react": "frontend",
-  "vue": "frontend",
-  "angular": "frontend",
-  "nextjs": "fullstack",
-  "nuxt": "fullstack",
-  "fastapi": "backend",
-  "express": "backend",
-  "django": "backend",
-  "rails": "backend"
-};
-```
-
-**Check Existing Rules**:
-```bash
-normalized_name=$(echo "$TECH_STACK_NAME" | tr '[:upper:]' '[:lower:]' | tr ' ' '-')
-rules_dir=".claude/rules/tech/${normalized_name}"
-existing_count=$(find "${rules_dir}" -name "*.md" 2>/dev/null | wc -l || echo 0)
-```
-
-**Skip Decision**:
-- If `existing_count > 0` AND no `--regenerate` → `SKIP_GENERATION = true`
-- If `--regenerate` → Delete existing and regenerate
-
-**Output Variables**:
-- `TECH_STACK_NAME`: Normalized name
-- `PRIMARY_LANG`: Primary language
-- `FILE_EXT`: File extension pattern
-- `FRAMEWORK_TYPE`: frontend | backend | fullstack | library
-- `COMPONENTS`: Array of tech components
-- `SKIP_GENERATION`: Boolean
-
-**TodoWrite**: Mark phase 1 completed
-
----
-
-### Phase 2: Agent Produces Path-Conditional Rules
-
-**Skip Condition**: Skipped if `SKIP_GENERATION = true`
-
-**Goal**: Delegate to agent for Exa research and rule file generation
-
-**Template Files**:
-```
-~/.claude/workflows/cli-templates/prompts/rules/
-├── tech-rules-agent-prompt.txt  # Agent instructions
-├── rule-core.txt                # Core principles template
-├── rule-patterns.txt            # Implementation patterns template
-├── rule-testing.txt             # Testing rules template
-├── rule-config.txt              # Configuration rules template
-├── rule-api.txt                 # API rules template (backend)
-└── rule-components.txt          # Component rules template (frontend)
-```
-
-**Agent Task**:
-
-```javascript
-Task({
-  subagent_type: "general-purpose",
-  description: `Generate tech stack rules: ${TECH_STACK_NAME}`,
-  prompt: `
-You are generating path-conditional rules for Claude Code.
-
-## Context
-- Tech Stack: ${TECH_STACK_NAME}
-- Primary Language: ${PRIMARY_LANG}
-- File Extensions: ${FILE_EXT}
-- Framework Type: ${FRAMEWORK_TYPE}
-- Components: ${JSON.stringify(COMPONENTS)}
-- Output Directory: .claude/rules/tech/${TECH_STACK_NAME}/
-
-## Instructions
-
-Read the agent prompt template for detailed instructions:
-$(cat ~/.claude/workflows/cli-templates/prompts/rules/tech-rules-agent-prompt.txt)
-
-## Execution Steps
-
-1. Execute Exa research queries (see agent prompt)
-2. Read each rule template
-3. Generate rule files following template structure
-4. Write files to output directory
-5. Write metadata.json
-6. Report completion
-
-## Variable Substitutions
-
-Replace in templates:
-- {TECH_STACK_NAME} → ${TECH_STACK_NAME}
-- {PRIMARY_LANG} → ${PRIMARY_LANG}
-- {FILE_EXT} → ${FILE_EXT}
-- {FRAMEWORK_TYPE} → ${FRAMEWORK_TYPE}
-`
-})
-```
-
-**Completion Criteria**:
-- 4-6 rule files written with proper `paths` frontmatter
-- metadata.json written
-- Agent reports files created
-
-**TodoWrite**: Mark phase 2 completed
-
----
-
-### Phase 3: Verify & Report
-
-**Goal**: Verify generated files and provide usage summary
-
-**Steps**:
-
-1. **Verify Files**:
-   ```bash
-   find ".claude/rules/tech/${TECH_STACK_NAME}" -name "*.md" -type f
-   ```
-
-2. **Validate Frontmatter**:
-   ```bash
-   head -5 ".claude/rules/tech/${TECH_STACK_NAME}/core.md"
-   ```
-
-3. **Read Metadata**:
-   ```javascript
-   Read(`.claude/rules/tech/${TECH_STACK_NAME}/metadata.json`)
-   ```
-
-4. **Generate Summary Report**:
-   ```
-   Tech Stack Rules Generated
-
-   Tech Stack: {TECH_STACK_NAME}
-   Location: .claude/rules/tech/{TECH_STACK_NAME}/
-
-   Files Created:
-   ├── core.md         → paths: **/*.{ext}
-   ├── patterns.md     → paths: src/**/*.{ext}
-   ├── testing.md      → paths: **/*.{test,spec}.{ext}
-   ├── config.md       → paths: *.config.*
-   ├── api.md          → paths: **/api/**/* (if backend)
-   └── components.md   → paths: **/components/**/* (if frontend)
-
-   Auto-Loading:
-   - Rules apply automatically when editing matching files
-   - No manual loading required
-
-   Example Activation:
-   - Edit src/components/Button.tsx → core.md + patterns.md + components.md
-   - Edit tests/api.test.ts → core.md + testing.md
-   - Edit package.json → config.md
-   ```
-
-**TodoWrite**: Mark phase 3 completed
-
----
-
-## Path Pattern Reference
-
-| Pattern | Matches |
-|---------|---------|
-| `**/*.ts` | All .ts files |
-| `src/**/*` | All files under src/ |
-| `*.config.*` | Config files in root |
-| `**/*.{ts,tsx}` | .ts and .tsx files |
-
-| Tech Stack | Core Pattern | Test Pattern |
-|------------|--------------|--------------|
-| TypeScript | `**/*.{ts,tsx}` | `**/*.{test,spec}.{ts,tsx}` |
-| Python | `**/*.py` | `**/test_*.py, **/*_test.py` |
-| Rust | `**/*.rs` | `**/tests/**/*.rs` |
-| Go | `**/*.go` | `**/*_test.go` |
-
----
-
-## Parameters
-
-```bash
-/memory:tech-research [session-id | "tech-stack-name"] [--regenerate]
-```
-
-**Arguments**:
-- **session-id**: `WFS-*` format - Extract from workflow session
-- **tech-stack-name**: Direct input - `"typescript"`, `"typescript-react"`
-- **--regenerate**: Force regenerate existing rules
-
----
-
-## Examples
-
-### Single Language
-
-```bash
-/memory:tech-research "typescript"
-```
-
-**Output**: `.claude/rules/tech/typescript/` with 4 rule files
-
-### Frontend Stack
-
-```bash
-/memory:tech-research "typescript-react"
-```
-
-**Output**: `.claude/rules/tech/typescript-react/` with 5 rule files (includes components.md)
-
-### Backend Stack
-
-```bash
-/memory:tech-research "python-fastapi"
-```
-
-**Output**: `.claude/rules/tech/python-fastapi/` with 5 rule files (includes api.md)
-
-### From Session
-
-```bash
-/memory:tech-research WFS-user-auth-20251104
-```
-
-**Workflow**: Extract tech stack from session → Generate rules
-
----
-
-## Comparison: Rules vs SKILL
-
-| Aspect | SKILL Memory | Rules |
-|--------|--------------|-------|
-| Loading | Manual: `Skill("tech")` | Automatic by path |
-| Scope | All files when loaded | Only matching files |
-| Granularity | Monolithic packages | Per-file-type |
-| Context | Full package | Only relevant rules |
-
-**When to Use**:
-- **Rules**: Tech stack conventions per file type
-- **SKILL**: Reference docs, APIs, examples for manual lookup