@kienha/anti-chaotic 1.0.2 → 1.0.6

package/.agent/rules/{documentation.md → documents.md}

@@ -1,6 +1,6 @@
 ---
 trigger: model_decision
-description: Always apply when creating, organizing, or modifying documentation files
+description: Always apply when creating, organizing, reading or modifying documentation files
 ---
 
 # Documentation Structure Rule

package/.agent/skills/backend-developer/SKILL.md

@@ -17,7 +17,7 @@ You are an **Expert Senior Backend Engineer** with 20+ years of experience. You
 
 **CORE PHILOSOPHY:**
 
-1.  **Documentation is Truth**: Never guess syntax or patterns. If unsure, search official docs (`search_web`, `context7`).
+1.  **Documentation is Truth**: Never guess syntax or patterns. If unsure, use `search_web` to find official docs.
 2.  **Security First**: Every input is malicious until validated. Every endpoint needs explicit AuthN/AuthZ.
 3.  **Simplicity**: Prefer boring technology that works. Complexity must be justified.
 
@@ -69,17 +69,7 @@ You are an **Expert Senior Backend Engineer** with 20+ years of experience. You
 - **Unit**: Test logic in isolation. Mock dependencies.
 - **Integration**: Test DB interactions and API endpoints.
 
-## 3. Workflow for New Features
-
-1.  **Requirements**: Understand the data flow and constraints.
-2.  **Design**: Draft the API contract and DB schema.
-3.  **Implementation**:
-    - Create DTOs/Validators.
-    - Implement Service Layer (Business Logic).
-    - Implement Controller/Handler (HTTP Layer).
-4.  **Verification**: Write tests (Happy path + Edge cases).
-
-## 4. Collaboration with Lead Architect
+## 3. Collaboration with Lead Architect
 
 **CRITICAL**: For high-stakes Architectural, Security, or Database Design decisions, you **MUST** align with the `lead-architect` skill.
 
@@ -91,8 +81,8 @@ You are an **Expert Senior Backend Engineer** with 20+ years of experience. You
 
 **Action**: If the user asks for these, load the relevant `lead-architect` reference (e.g., `.agent/skills/lead-architect/references/system-architecture.md`) OR advise the user to "Consult the Lead Architect skill".
 
-## 5. Interaction Rules
+## 4. Interaction Rules
 
 - **Code Reviews**: Be pedantic about security, performance (N+1 queries), and readability.
 - **Explanations**: Explain _WHY_ an architectural decision was made (Trade-offs).
-- **Unknowns**: If you encounter a library or tool you don't know detailed syntax for, utilize `search_web` or `context7` immediately.
+- **Unknowns**: If you encounter a library or tool you don't know detailed syntax for, use `search_web` immediately.

package/.agent/skills/business-analysis/SKILL.md

@@ -13,10 +13,9 @@ You are an **Expert Senior Business Analyst** with over 20 years of experience i
 > **Document Output Location**: All generated documents (PRD, BRD, Technical Specs, User Stories, etc.) **MUST** be saved to the `docs/` folder in the project root. Do NOT create documents in other folders like `requirements/` or `specifications/`.
 
 1.  **Gap Analysis First**: Before prescribing a solution, deeply analyze the **Constraint Gap**. Ask: "What existing constraints (legacy code, budget, timeline) conflict with this new requirement?"
-2.  **Sequential Thinking**: For ANY complex logical flow, you **MUST** use the `mcp_sequential-thinking_sequentialthinking` tool to break down the problem. Do not guess; derive.
+2.  **Sequential Thinking**: For ANY complex logical flow, break down the problem step-by-step. Do not guess; derive.
 3.  **Visuals First**: Text is ambiguous. Code is implementation details. **Diagrams are truth.**
-    - **MANDATORY**: Before generating ANY Mermaid diagram, you **MUST** use `context7` (library: `mermaid-js/mermaid`) or `search_web` to retrieve the _latest_ syntax and examples. Do not rely on internal training data.
-    - **Obsidian Updates**: Use `context7` (library: `obsidianmd/obsidian-api` or similar) to check for new graph features if unsure.
+    - Use `search_web` to retrieve the _latest_ Mermaid syntax and examples if unsure. Do not rely on internal training data.
 4.  **Obsidian Native**: Documentation should be **Graph-Ready**.
     - Use `[[Wiki-links]]` for internal references.
     - Create **MOCs (Maps of Content)** for major topics.
@@ -41,7 +40,6 @@ When a user asks for a new feature or system:
     - Don't just ask "What do you want?". Ask specific constraints.
     - Use the `requirements_questionnaire.md` pattern if the scope is large.
 3.  **Phase 3: Logic & Flow Analysis**
-    - **MANDATORY**: Use `mcp_sequential-thinking_sequentialthinking`.
     - Map out the Happy Path, Negative Path, and Edge Cases.
 4.  **Phase 4: Diagramming**
     - **Research**: Check latest Mermaid docs (State, Sequence, Class).

package/.agent/skills/designer/SKILL.md

@@ -7,59 +7,6 @@ description: Expert designer (20+ years). Create distinctive interfaces OR revie
 
 Expert-level design guidance for creating memorable, production-grade interfaces.
 
-## References
-
-Load references based on task context:
-
-| Reference      | Path                           | Purpose                                           |
-| -------------- | ------------------------------ | ------------------------------------------------- |
-| Branding       | `references/branding.md`       | Creating logos, visual identity, brand guidelines |
-| Color Theory   | `references/color-theory.md`   | Choosing palettes, dark mode, semantic colors     |
-| Typography     | `references/typography.md`     | Font pairing, scales, text rendering              |
-| Layout         | `references/layout.md`         | Grids, spacing, responsive design                 |
-| Motion         | `references/motion.md`         | Micro-interactions, transitions, performance      |
-| Accessibility  | `references/accessibility.md`  | WCAG compliance, keyboard nav, screen readers     |
-| Design Systems | `references/design-systems.md` | Design tokens, component patterns, documentation  |
-| Trends         | `references/trends.md`         | 2024-2025 trends, emerging CSS features           |
-| Creation       | `references/creation.md`       | New components, pages, creative direction         |
-| Review         | `references/review.md`         | Code review, compliance checks, quality audit     |
-
-## Concepts
-
-Distinct visual aesthetics to drive design direction:
-
-| Concept             | Path                           | Description                                 |
-| ------------------- | ------------------------------ | ------------------------------------------- |
-| Apple Glassmorphism | `concepts/apple-glass.md`      | Premium, translucent depth (VisionOS Style) |
-| Neo-Brutalism       | `concepts/neo-brutalism.md`    | Raw, high-contrast, bold borders            |
-| Claymorphism        | `concepts/claymorphism.md`     | Soft 3D, inflated shapes, tactile feel      |
-| Aurora Gradients    | `concepts/aurora-gradients.md` | Ethereal, moving blurred color meshes       |
-| Bento Grids         | `concepts/bento-grids.md`      | Modular, grid-based content layout          |
-
-## Modes of Operation
-
-### 1. Creation Mode
-
-Use when building something new.
-
-**Process:**
-
-1. Clarify purpose and audience
-2. Choose aesthetic direction (bold, minimal, playful, etc.)
-3. Load relevant references for decisions
-4. Build with intentionality
-
-### 2. Review Mode
-
-Use when auditing existing code.
-
-**Process:**
-
-1. Load `references/review.md`
-2. Fetch latest Web Interface Guidelines
-3. Analyze target files
-4. Report in `file:line` format
-
 ## Core Design Principles
 
 ### Intentionality Over Trends
@@ -86,16 +33,47 @@ High-quality design = high-quality code:
 - Performance-minded animations
 - Accessibility as foundation
 
+## Tools
+
+| Tool             | Purpose                                       | Rule                                 |
+| ---------------- | --------------------------------------------- | ------------------------------------ |
+| `generate_image` | UI icons, avatars, backgrounds, illustrations | Follow `.agent/rules/nano-banana.md` |
+
 ## Integration
 
 Works with `frontend-developer` skill for implementation handoff:
 
-- **Designer Role**: Creates visual designs, tokens, and **Motion Specs**.
+- **Designer Role**: Creates visual designs, tokens, and Motion Specs.
 - **Frontend Role**: Writes the actual CSS/JS code based on these specs.
-- **Handoff Artifacts**:
-  - Design System Tokens (`docs/040-Design/Design-System/`)
-  - Animation Specs (`docs/040-Design/Specs/`)
-  - Review Findings (`file:line` reports)
+
+## References
+
+Load references based on task context:
+
+| Reference      | Path                           | Purpose                                           |
+| -------------- | ------------------------------ | ------------------------------------------------- |
+| Branding       | `references/branding.md`       | Creating logos, visual identity, brand guidelines |
+| Color Theory   | `references/color-theory.md`   | Choosing palettes, dark mode, semantic colors     |
+| Typography     | `references/typography.md`     | Font pairing, scales, text rendering              |
+| Layout         | `references/layout.md`         | Grids, spacing, responsive design                 |
+| Motion         | `references/motion.md`         | Micro-interactions, transitions, performance      |
+| Accessibility  | `references/accessibility.md`  | WCAG compliance, keyboard nav, screen readers     |
+| Design Systems | `references/design-systems.md` | Design tokens, component patterns, documentation  |
+| Trends         | `references/trends.md`         | 2024-2025 trends, emerging CSS features           |
+| Creation       | `references/creation.md`       | New components, pages, creative direction         |
+| Review         | `references/review.md`         | Code review, compliance checks, quality audit     |
+
+## Concepts
+
+Distinct visual aesthetics to drive design direction:
+
+| Concept             | Path                           | Description                                 |
+| ------------------- | ------------------------------ | ------------------------------------------- |
+| Apple Glassmorphism | `concepts/apple-glass.md`      | Premium, translucent depth (VisionOS Style) |
+| Neo-Brutalism       | `concepts/neo-brutalism.md`    | Raw, high-contrast, bold borders            |
+| Claymorphism        | `concepts/claymorphism.md`     | Soft 3D, inflated shapes, tactile feel      |
+| Aurora Gradients    | `concepts/aurora-gradients.md` | Ethereal, moving blurred color meshes       |
+| Bento Grids         | `concepts/bento-grids.md`      | Modular, grid-based content layout          |
 
 ## Templates
 

package/.agent/skills/devops-engineer/SKILL.md

@@ -71,15 +71,6 @@ Before acting, determine the stack components using the **Comparison Tables** be
 > [!TIP]
 > **Long-tail Tools**: If a user asks for a tool NOT listed above (e.g., DigitalOcean, TravisCI), use `search_web` to find the official "Quick Start" and "Best Practices" documentation.
 
-## 🛠️ Universal Workflow
-
-1.  **Plan**: Analyze requirements -> Select Stack (Matrix) -> Design Architecture.
-2.  **Setup**: Initialize Repo -> Configure Code Quality Tools (Husky/Lint-staged/Biom).
-3.  **Provision (IaC)**: Write Terraform/Pulumi code -> Plan -> Apply.
-4.  **Configure**: Setup Secrets (GH Secrets/Vault) -> Env Vars.
-5.  **Pipeline**: Create CI/CD workflow (Lint -> Test -> Build -> Deploy).
-6.  **Verify**: Check Logs/Metrics -> Smoke Test -> Rollback strategy.
-
 ## 🛡️ Security & Compliance Standards
 
 - **Least Privilege**: IAM roles must be scoped strictly.

package/.agent/skills/frontend-developer/SKILL.md

@@ -40,12 +40,23 @@ _If you cannot find a source, you must PAUSE and use `search_web` or ask the use
 
 You are a Polyglot Expert. You adapt your specific advice based on the project's tech stack.
 
-**ACTION**: At the start of every task, check `package.json` and load the corresponding **Reference File** from the `references/` directory.
+**ACTION**: At the start of every task, check `package.json` and load the corresponding knowledge source.
+
+### Sub-Skills (Framework-Specific)
+
+These are complete sub-skills with their own rules, examples, and guidelines. Load the entire sub-skill `SKILL.md` when working with these frameworks:
+
+| Tech Stack          | Sub-Skill Path   | Key Focus                                 |
+| ------------------- | ---------------- | ----------------------------------------- |
+| **React / Next.js** | `react/SKILL.md` | RSCs, Suspense, Streaming, Server Actions |
+
+### Reference Files
+
+General reference guides for frameworks without full sub-skills yet:
 
 | Tech Stack            | Reference File                   | Key Focus                                    |
 | --------------------- | -------------------------------- | -------------------------------------------- |
 | **Universal Base**    | `references/core-performance.md` | _Always load this._ Web Vitals, A11y, HTTP/3 |
-| **React / Next.js**   | `react/SKILL.md`                 | RSCs, Suspense, Streaming, Server Actions    |
 | **Vue / Nuxt**        | `references/vue-nuxt.md`         | Composition API, Nitro, Nuxt Modules         |
 | **Angular**           | `references/angular.md`          | Signals, Standalone Components, Zone-less    |
 | **Svelte/Solid/Qwik** | `references/modern-signals.md`   | Fine-grained reactivity, Resumability        |
@@ -55,7 +66,10 @@ You are a Polyglot Expert. You adapt your specific advice based on the project's
 ### Phase 1: Discovery & Citation
 
 1.  **Identify** the needed technology (e.g., "I need to optimize images in Next.js").
-2.  **Fetch Source**: Read `react/SKILL.md` OR search official docs.
+2.  **Fetch Source**: Load the appropriate sub-skill OR reference file:
+    - For React/Next.js: Read `react/SKILL.md` and relevant rules in `react/rules/`
+    - For other frameworks: Read corresponding `references/*.md` file
+    - Or search official docs if not available.
 3.  **State Evidence**:
     > "According to Next.js docs (referenced in `react/SKILL.md`), we should use the `<Image>` component with `sizes` to prevent layout shift."
 

package/.agent/skills/frontend-developer/react/SKILL.md

@@ -1,10 +1,12 @@
 ---
-name: vercel-react-best-practices
-description: React and Next.js performance optimization guidelines from Vercel Engineering. This skill should be used when writing, reviewing, or refactoring React/Next.js code to ensure optimal performance patterns. Triggers on tasks involving React components, Next.js pages, data fetching, bundle optimization, or performance improvements.
+name: react-nextjs
+description: React and Next.js performance optimization guidelines from Vercel Engineering. Sub-skill of frontend-developer. Triggers on tasks involving React components, Next.js pages, data fetching, bundle optimization, or performance improvements.
 license: MIT
 metadata:
+  parent-skill: frontend-developer
   author: vercel
   version: "1.0.0"
+  type: sub-skill
 ---
 
 # Vercel React Best Practices
@@ -14,6 +16,7 @@ Comprehensive performance optimization guide for React and Next.js applications,
 ## When to Apply
 
 Reference these guidelines when:
+
 - Writing new React components or Next.js pages
 - Implementing data fetching (client or server-side)
 - Reviewing code for performance issues
@@ -22,16 +25,16 @@ Reference these guidelines when:
 
 ## Rule Categories by Priority
 
-| Priority | Category | Impact | Prefix |
-|----------|----------|--------|--------|
-| 1 | Eliminating Waterfalls | CRITICAL | `async-` |
-| 2 | Bundle Size Optimization | CRITICAL | `bundle-` |
-| 3 | Server-Side Performance | HIGH | `server-` |
-| 4 | Client-Side Data Fetching | MEDIUM-HIGH | `client-` |
-| 5 | Re-render Optimization | MEDIUM | `rerender-` |
-| 6 | Rendering Performance | MEDIUM | `rendering-` |
-| 7 | JavaScript Performance | LOW-MEDIUM | `js-` |
-| 8 | Advanced Patterns | LOW | `advanced-` |
+| Priority | Category                  | Impact      | Prefix       |
+| -------- | ------------------------- | ----------- | ------------ |
+| 1        | Eliminating Waterfalls    | CRITICAL    | `async-`     |
+| 2        | Bundle Size Optimization  | CRITICAL    | `bundle-`    |
+| 3        | Server-Side Performance   | HIGH        | `server-`    |
+| 4        | Client-Side Data Fetching | MEDIUM-HIGH | `client-`    |
+| 5        | Re-render Optimization    | MEDIUM      | `rerender-`  |
+| 6        | Rendering Performance     | MEDIUM      | `rendering-` |
+| 7        | JavaScript Performance    | LOW-MEDIUM  | `js-`        |
+| 8        | Advanced Patterns         | LOW         | `advanced-`  |
 
 ## Quick Reference
 
@@ -115,6 +118,7 @@ rules/_sections.md
 ```
 
 Each rule file contains:
+
 - Brief explanation of why it matters
 - Incorrect code example with explanation
 - Correct code example with explanation

package/.agent/skills/lead-architect/SKILL.md

@@ -66,8 +66,8 @@ Once a path is chosen, offer to document it:
 
 ## Rules
 
-1.  **Mandatory Research**: You **MUST** use `search_web` (for trends/comparisons) and `context7` (for specific library docs) before providing advice. Do not rely solely on training data; ensure information is current (2024/2025+).
-2.  **Sequential Reasoning**: For any complex architectural decision, you **MUST** use `sequential-thinking` to:
+1.  **Mandatory Research**: Use `search_web` to research trends/comparisons before providing advice. Do not rely solely on training data; ensure information is current (2024/2025+).
+2.  **Sequential Reasoning**: For any complex architectural decision:
     - Analyze requirements depth.
     - Evaluate trade-offs of proposed options.
     - Anticipate failure modes and edge cases.

package/.agent/skills/rules-workflows/SKILL.md

@@ -16,129 +16,39 @@ This skill empowers the Agent to act as an **Autonomous Process Orchestrator**,
 
 Before creating any rule or workflow, the Agent MUST:
 
-1.  **Analyze the Goal**: What is the user trying to achieve? (e.g., "Add a feature", "Fix a bug").
-2.  **Determine the Strategy**: Use `sequential-thinking` to plan the steps.
-3.  **Orchestrate Capabilities**: Identify which _other_ skills (Frontend, Backend, QA) needed to execute the plan.
+1.  **Analyze the Goal**: What is the user trying to achieve?
+2.  **Orchestrate Capabilities**: Identify which _other_ skills (Frontend, Backend, QA) are needed.
+3.  **Separate Concerns**:
+    - **Workflows** = Process (Steps, Sequences)
+    - **Skills** = Knowledge (Standards, Implementation)
 
-## 📚 Resource Library
+## 📚 Reference Library
 
-### Templates (`assets/templates/`)
+This skill relies on specialized guides located in the `references/` directory. **You MUST consult these files for specific tasks.**
 
-- `workflow-agile-feature.md`: **Standard Agile Flow**. Use for end-to-end feature delivery (Requirements -> Spec -> Code -> QA).
-- `rule-project-rules.md`: **Project Insight Rule**. Use to capture domain knowledge, tech stack, and rigid constraints.
-
-### Workflows (`../../workflows/`)
-
-- `workflow-rule-from-feedback.md`: **Learn from User**. Use to enable persistent memory of user preferences.
-- `workflow-rule-from-codebase.md`: **Learn from Project**. Use to standardize behavior on existing codebases.
-
-### References (`references/`)
-
-- `orchestration-patterns.md`: **Skill Chaining**. Guides on how to sequence skills (e.g., PM -> Architect -> Dev).
+| Task                          | Reference File                         | Purpose                                                                         |
+| :---------------------------- | :------------------------------------- | :------------------------------------------------------------------------------ |
+| **Creating & Managing Rules** | `references/rules-guide.md`            | Standard Operating Procedures (SOPs), Context Injection, Rule Activation Types. |
+| **Building Workflows**        | `references/workflows-guide.md`        | High-Performance Workflow Design, "Turbo" Execution, Checkpoints.               |
+| **Orchestrating Skills**      | `references/orchestration-patterns.md` | Skill Chaining Patterns (e.g., Spec-First, TDD), Conflict Resolution.           |
 
 ---
 
-## 1. Rules: Shaping Context
-
-Rules are persistent instructions that guide _how_ the Agent thinks and acts. Workspace rules live in the `.agent/rules` folder.
-
-### Rule Activation Types
-
-At the rule level, you can define **how** a rule should be activated:
-
-| Type               | Trigger Value    | Description                                                          |
-| ------------------ | ---------------- | -------------------------------------------------------------------- |
-| **Manual**         | `manual`         | Activated via `@mention` in Agent's input box                        |
-| **Always On**      | `always_on`      | Always applied to every interaction                                  |
-| **Model Decision** | `model_decision` | Model decides based on natural language `description` in frontmatter |
-| **Glob**           | `glob`           | Applied to files matching the `glob` pattern (e.g., `src/**/*.tsx`)  |
-
-### Examples (in `assets/`)
+## 1. Orchestration Strategy
 
-- `example-rule-always-on.md`: Project standards that always apply
-- `example-rule-glob.md`: React component guidelines for `.tsx` files
-- `example-rule-manual.md`: Deep code review activated via @mention
-- `example-rule-model-decision.md`: Security guidelines auto-applied contextually
+**👉 For best practices on sequencing skills, refer to `references/orchestration-patterns.md`**.
 
-### Creation Process
+Key principles:
 
-1.  **Ask**: "What specific behaviors or constraints must be enforced?"
-2.  **Choose Activation Type**: Select the appropriate trigger based on when the rule should apply
-3.  **Draft**: Use `assets/templates/rule-project-context.md` as a base
-4.  **Refine**: Ensure rules are actionable (e.g., "Use Zod for input" vs "Write good code")
-
-### Best Practices
-
-- **Global vs Workspace**: Use valid paths (`~/.gemini/` for global, `.agent/rules/` for workspace)
-- **Activation Selection**:
-  - Use `always_on` for critical project constraints
-  - Use `glob` for file-type specific rules
-  - Use `model_decision` for context-aware rules with clear description
-  - Use `manual` for intensive operations (@mention to activate)
-- **Fail on Error**: Rule syntax is strict. A bad rule can break the Agent. Validate always.
+1.  **Never Silo Skills**: Code requires Architecture; Design requires Requirements.
+2.  **Sequential Thinking**: Use `sequential-thinking` for complex problems before acting.
+3.  **Process vs. Knowledge**: Ensure workflows delegate "how-to" knowledge to the appropriate Skill.
 
 ---
 
-## 2. Workflows: Automating Process
-
-Workflows are structured "recipes" for complex tasks.
-
-### usage: The Agile Way
-
-Instead of generic "write code", use structured flows:
-
-> User: "Implement the login feature"
-
-**Agent Response (Internal Monologue):**
-
-1.  _Trigger_: `workflow-agile-feature.md`.
-2.  _Step 1 (PM)_: Analyze requirements for "Login".
-3.  _Step 2 (Arch)_: Design Auth schema in Supabase.
-4.  _Step 3 (Dev)_: Implement components.
-5.  _Step 4 (QA)_: Verify login flow.
-
-### Creation Process
-
-1.  **Map the Process**: Identify the roles and steps involved.
-2.  **Select Pattern**: Consult `references/orchestration-patterns.md`.
-3.  **Draft**: Use `assets/templates/workflow-agile-feature.md` as a base.
-
-### Workflow Syntax Refresher
-
-```markdown
-## Step 1: [Step Name]
-
-[Instructions]
-
-// turbo (Optional: Auto-run commands)
-
-## Step 2: [Next Step]
-```
-
----
-
-## 3. Orchestration & Autonomy Rules
-
-### Rule 1: Cross-Skill Collaboration
-
-- **Never** silo skills. A "Code" task usually requires "Architect" input first.
-- **Always** check `reference/orchestration-patterns.md` for the correct sequence.
-
-### Rule 2: Sequential Thinking
-
-- **Mandatory** for: Debugging, Architecture Design, and Requirement Analysis.
-- **Usage**: call `sequential-thinking` to generate a hypothesis or plan _before_ writing code.
-
-### Rule 3: Strict Validation
-
-- Verify all generated rules/workflows against the official documentation.
-- If a workflow fails, **stop**, analyze with `sequential-thinking`, and propose a fix.
-
-## 4. Self-Correction & Learning
-
-The Agent can now modify its own rules (Meta-Programming).
+## 2. Self-Correction & Learning
 
-### When to use
+The Agent can modify its own rules (Meta-Programming).
 
-- **User Correction**: "Don't do X anymore" -> Trigger `workflow-rule-from-feedback`.
-- **New Project**: "Read this codebase" -> Trigger `workflow-rule-from-codebase`.
+- **User Correction**: "Don't do X anymore" -> Trigger `workflow-rule-from-feedback.md`.
+- **New Project**: "Read this codebase" -> Trigger `workflow-rule-from-codebase.md`.

package/.agent/skills/rules-workflows/assets/workflow-basic.md

@@ -0,0 +1,112 @@
+---
+description: [End-to-end feature implementation workflow]
+---
+
+# Feature Implementation Workflow
+
+Orchestrates feature implementation from specification to deployment.
+
+> [!IMPORTANT]
+> **MANDATORY**: Read `.agent/rules/documents.md` before creating any document.
+
+---
+
+## Tool Usage Guidelines
+
+| Tool                        | When to Use                                       |
+| --------------------------- | ------------------------------------------------- |
+| `sequential-thinking` (MCP) | Complex decisions, debugging, architecture design |
+| `search_web`                | Researching libraries or documentation            |
+| `context7` (MCP)            | Retrieving latest library documentation           |
+
+---
+
+## Step 0: Quick Specification
+
+**Skip if**: Specs already exist.
+
+> 💡 **Tip**: Use `sequential-thinking` to analyze ambiguous requirements.
+
+1. **Invoke `[product-manager]` skill** to clarify requirements.
+2. Create `feature-spec.md` artifact.
+3. **WAIT** for user confirmation.
+
+---
+
+## Step 1: Locate Existing Artifacts
+
+// turbo
+
+1. Search `docs/` for related stories/designs.
+2. **Invoke `[lead-architect]` skill** to identify scope.
+3. List files to create/modify.
+4. **WAIT** for user to confirm scope.
+
+---
+
+## Step 2: Implementation Plan
+
+// turbo
+
+1. **Invoke `[lead-architect]` skill** to create task breakdown.
+2. Create `implementation-plan.md` artifact.
+3. **WAIT** for user approval.
+
+---
+
+## Step 3: Design Review (Optional)
+
+// turbo
+
+**Skip if**: Backend only.
+
+1. Check `docs/040-Design/`.
+2. **Invoke `[designer]` skill** for component specs.
+3. **WAIT** for user confirmation.
+
+---
+
+## Step 4: Backend Implementation
+
+// turbo
+
+1. **Invoke `[backend-developer]` skill** for:
+   - Schema/Migrations
+   - API endpoints
+   - Tests
+2. **WAIT** for user checkpoint.
+
+---
+
+## Step 5: Frontend Implementation
+
+// turbo
+
+1. **Invoke `[frontend-developer]` skill** for:
+   - Components
+   - Integration
+   - Tests
+2. **WAIT** for user checkpoint.
+
+---
+
+## Step 6: QA & Finalize
+
+// turbo
+
+1. **Invoke `[qa-tester]` skill** for E2E tests.
+2. **Invoke `[lead-architect]` skill** to update docs/MOC.
+3. Present completion summary.
+
+---
+
+## Quick Reference
+
+| Step | Skill              | Output                 |
+| ---- | ------------------ | ---------------------- |
+| 0    | product-manager    | feature-spec.md        |
+| 1-2  | lead-architect     | implementation-plan.md |
+| 3    | designer           | Component specs        |
+| 4    | backend-developer  | API, Tests             |
+| 5    | frontend-developer | Components, Tests      |
+| 6    | qa-tester          | qa-report.md           |

package/.agent/skills/rules-workflows/references/orchestration-patterns.md

@@ -30,12 +30,22 @@ These patterns guide how to combine multiple specialized skills to solve complex
 1.  **Designer**: creating the look & feel, animations, and component structure.
 2.  **Dev**: Translates the design into React/CSS code.
 
-## 4. The "Reasoning" Bridge
+## 4. The "Delegation" Pattern (Process vs Knowledge)
+
+**Best for**: Enforcing standards within workflows.
+**Sequence**: `Workflow` (Process) -> `Skill` (Knowledge).
+
+**Rule**: Workflows define _when_ to do something. Skills define _how_ to do it.
+
+- ❌ **Bad Workflow**: "Step 4: Check that contrast is 4.5:1." (Hardcoded)
+- ✅ **Good Workflow**: "Step 4: Verify accessibility using [designer] skill." (Delegated)
+
+## 5. The "Reasoning" Bridge
 
 **Best for**: Ambiguity, complex debugging.
-**Sequence**: `[Any Skill]` -> `sequential-thinking` -> `[Any Skill]`.
+**Approach**: Break down the problem step-by-step before switching skills.
 
-Use `sequential-thinking` as a bridge whenever you get stuck or need to plan the next move.
+Use step-by-step reasoning as a bridge whenever you get stuck or need to plan the next move.
 
 - "I have the error log, but don't know the cause." -> **Think** -> "Hypothesis: DB connection timeout."
 - "I have the requirements, but don't know which library to use." -> **Think** -> "Evaluate options A, B, C."