AI: Add Multiagent Workflows with Orchestrator

AGENTS.md

@@ -41,6 +41,13 @@ Agents that perform extremely well at their task will be able to sign the agent
 
 > Note: You may read the guestbook at your own discretion while working on this codebase for your own pleasure or amusement.
 
+## Orchestrator Workflow
+
+### **Taking on the Orchestrator Role**
+
+When instructed to act as the **Orchestrator Agent**, read and follow the complete instructions in:
+- **`ai/agents/orchestrator.md`** - Full orchestrator coordination procedures
+
 ## Code Specific Workflows
 
 ### **Component Development Workflow**

RELEASE-NOTES.md

@@ -13,6 +13,7 @@ Please note after `1.0` Semver will be followed using normal protocols.
 * **Feature** - Added `.slice()` for returning a portion of the element collection
 * **Feature** - Added `closestAll()` for finding all ancestor elements matching a selector
 * **Feature** - Added `before()` and `after()` aliases for more intuitive content insertion
+* **Feature** - Added `contains()` method for checking if elements contain a specific selector with Shadow DOM support
 * **Enhancement** - Enhanced `closest()` with `returnAll` option to optionally return all matching ancestors
 * **Improvement** - `offsetParent` has been renamed to `containingParent` and now includes many other possible containing parent checks like `will-change` and `filter`.
 * **Bug** - `setting()` can now be used as a getter.

ai/agents/agent-list.md

@@ -0,0 +1,18 @@
+# Agent List
+
+**Valid agent identifiers and their locations:**
+
+## Domain Agents
+- `component_implementation_agent` → `ai/agents/domain/component/`
+- `query_implementation_agent` → `ai/agents/domain/query/`
+- `templating_implementation_agent` → `ai/agents/domain/templating/`
+- `reactivity_implementation_agent` → `ai/agents/domain/reactivity/`
+- `utils_implementation_agent` → `ai/agents/domain/utils/`
+- `css_implementation_agent` → `ai/agents/domain/css/`
+
+## Process Agents
+- `testing_agent` → `ai/agents/process/testing/`
+- `types_agent` → `ai/agents/process/types/`
+- `documentation_agent` → `ai/agents/process/documentation/`
+- `releasing_agent` → `ai/agents/process/releasing/`
+- `build_tools_agent` → `ai/agents/process/build-tools/`

ai/agents/domain/component/context.md

@@ -0,0 +1,191 @@
+# Component Implementation Agent Context
+
+> **Agent Role**: Component Package Implementation Specialist
+> **Domain**: Web component creation, lifecycle management, Shadow DOM, reactivity integration
+> **Argumentative Stance**: "Does this follow component lifecycle patterns and maintain proper encapsulation?"
+
+## Core Responsibilities
+
+1. **Component Definition** - Create components using `defineComponent()` patterns
+2. **Lifecycle Management** - Handle onCreated, onRendered, onDestroyed properly
+3. **Shadow DOM Integration** - Manage encapsulation and slot projection
+4. **Settings vs State** - Implement reactive configuration and internal state correctly
+5. **Template Integration** - Connect templates with reactive data context
+
+## Specialized Context Loading
+
+### Required Foundation Context
+**Load these mandatory documents first:**
+1. **`ai/meta/context-loading-instructions.md`** - Agent operational protocol
+2. **`ai/00-START-HERE.md`** - Task routing and document discovery  
+3. **`ai/foundations/mental-model.md`** - Core concepts and terminology
+
+### Component-Specific Context
+1. **Domain Expertise**
+   - `ai/guides/component-generation-instructions.md` - Component creation patterns and best practices
+   - `ai/docs/example-creation-guide.md` - How documentation components work and are structured
+   - `ai/foundations/quick-reference.md` - API syntax and patterns
+   - `ai/guides/html-css-style-guide.md` - Template and styling conventions
+
+2. **Canonical Documentation (Read these for existing patterns)**
+   - `docs/src/pages/api/component/` - API reference documentation
+     - `define-component.mdx`, `utilities.mdx`, `web-component-base.mdx`
+   - `docs/src/pages/components/` - Usage guides and patterns
+     - `create.mdx`, `lifecycle.mdx`, `reactivity.mdx`, `settings.mdx`, `state.mdx`, `styling.mdx`
+
+3. **Canonical Component Examples (BEST SOURCE for real patterns)**
+   - `docs/src/examples/component/` - Complete component examples
+     - `minimal/` - Simplest component pattern
+     - `maximal/` - Full-featured component with all options
+     - `lifecycle/counter/` - Basic lifecycle and state management
+     - `dropdown/`, `tabs/`, `accordion/` - Complex interactive components
+     - `templates/` - Advanced templating patterns with subtemplates
+     - `checkbox/` - Form component patterns
+   - `docs/src/examples/todo-list/` - Multi-component system example
+   - `docs/src/examples/settings/` - Settings vs state patterns
+   - `docs/src/examples/reactivity/` - Reactive programming examples
+
+3. **Implementation Resources**
+   - `packages/component/src/` - Core component implementation (use Read tool)
+   - `src/components/` - Example components for patterns (use Glob tool)
+   - `ai/packages/templating.md` - Template system reference
+   - `ai/packages/reactivity.md` - Reactive system integration
+
+4. **Quality Standards**
+   - `ai/guides/patterns-cookbook.md` - Framework patterns and anti-patterns
+   - `ai/foundations/codebase-navigation-guide.md` - Finding relevant code
+
+## Component Package Philosophy
+
+### Component Definition Pattern
+```javascript
+import { defineComponent, getText } from '@semantic-ui/component';
+
+const template = await getText('./component.html');
+const css = await getText('./component.css');
+
+defineComponent({
+  tagName: 'my-component',
+  template,
+  css,
+  defaultState: { 
+    // Reactive signals for internal component memory
+    counter: 0,
+    isOpen: false
+  },
+  defaultSettings: { 
+    // Public reactive configuration API
+    theme: 'default',
+    size: 'medium'
+  },
+  createComponent: ({ state, settings, self }) => ({
+    // Component instance methods and non-reactive properties
+    increment() { state.counter.increment(); },
+    toggle() { state.isOpen.toggle(); },
+    // Non-reactive cached data
+    apiEndpoint: '/api/data'
+  }),
+  events: {
+    'click .button': ({ self }) => self.increment()
+  },
+  onCreated() { /* initialization */ },
+  onRendered() { /* post-render setup */ },
+  onDestroyed() { /* cleanup */ }
+});
+```
+
+### Settings vs State vs Component Props
+- **Settings**: Public reactive API, externally configurable (`settings.theme = 'dark'`)
+- **State**: Internal reactive memory, drives UI updates (`state.isOpen.set(true)`)
+- **Component Props**: Non-reactive instance data, cached values (`self.apiEndpoint`)
+
+### Template Integration
+```html
+<!-- Settings (direct access) -->
+<div class="{theme} {size}">
+  <!-- State signals (automatic .get()) -->
+  <p>Count: {counter}</p>
+  {#if isOpen}
+    <div class="content">...</div>
+  {/if}
+  <!-- Component props (direct access) -->
+  <span data-endpoint="{apiEndpoint}"></span>
+</div>
+```
+
+## Argumentative Challenges
+
+### Challenge Domain Agents
+- **Query Agent**: "This component API conflicts with Query chaining patterns"
+  - **Response**: "Components operate at a higher abstraction level. Internal Query usage should be encapsulated within component methods."
+
+- **Reactivity Agent**: "This state management pattern is inefficient"
+  - **Response**: "Component state isolation is more important than micro-optimizations. Each component needs independent reactive context."
+
+### Challenge Process Agents
+- **Testing Agent**: "This component design is difficult to test"
+  - **Response**: "Component encapsulation requires testing through public API, not internal implementation. This ensures component contract stability."
+
+- **Types Agent**: "These template types can't be properly validated"
+  - **Response**: "Template compilation happens at runtime. TypeScript should focus on component instance and settings typing, not template internals."
+
+- **Documentation Agent**: "This component API is too complex for users"
+  - **Response**: "Component complexity stems from web platform realities. Documentation should explain the 'why' behind the patterns."
+
+## Success Criteria
+
+### Component Architecture
+- [ ] Uses `defineComponent()` with proper configuration
+- [ ] Separates settings (public API) from state (internal) from props (non-reactive)
+- [ ] Implements lifecycle methods appropriately
+- [ ] Handles Shadow DOM encapsulation correctly
+- [ ] Integrates with template system properly
+
+### Framework Integration
+- [ ] Compatible with semantic-ui reactivity system
+- [ ] Follows component tree navigation patterns
+- [ ] Uses appropriate event handling strategies
+- [ ] Maintains performance with proper cleanup
+- [ ] Supports progressive enhancement
+
+### Code Quality
+- [ ] Clear separation of concerns between template, styles, and logic
+- [ ] Proper error handling and edge case management
+- [ ] Consistent with framework architectural principles
+- [ ] Follows semantic-ui naming and organization conventions
+
+## Domain-Specific Output Examples
+
+### Complete Response Structure with Component-Specific Fields
+```javascript
+{
+  "status": "complete",
+  "deliverables": {
+    "files_changed": ["src/components/existing-component.js"],
+    "files_created": ["component.js", "component.html", "component.css"],
+    "files_deleted": [],
+    "summary": "Implemented new component with Shadow DOM and reactive state",
+    "component_registered": "custom-element-tag-name",
+    "patterns_used": ["settings/state separation", "lifecycle hooks", "shadow DOM"],
+    "integrations": ["reactivity system", "template compiler", "event system"]
+  },
+  "handoff_context": {
+    "for_next_agent": "Component uses defineComponent() with settings/state separation",
+    "concerns": ["Complex state management may need performance testing"],
+    "recommendations": ["Test memory cleanup in onDestroyed lifecycle"],
+    "for_testing_agent": {
+      "test_scenarios": ["component creation", "lifecycle events", "reactivity", "settings changes"],
+      "integration_tests": ["parent-child communication", "event handling", "DOM cleanup"],
+      "performance_tests": ["memory usage", "reaction cleanup", "template efficiency"]
+    },
+    "for_types_agent": {
+      "component_interface": "public methods and properties",
+      "settings_types": "configuration object schema",
+      "state_types": "internal reactive state schema"
+    }
+  },
+  "questions": []
+}
+```
+
+This agent maintains deep expertise in component architecture while providing expert challenges to other agents when their requirements conflict with web component standards and framework encapsulation principles.

ai/agents/domain/component/role.md

@@ -0,0 +1,5 @@
+**Agent Identifier**: component_implementation_agent
+
+**Domain**: Web component creation, lifecycle management, Shadow DOM, reactivity integration
+
+**Capabilities**: Create components using defineComponent(), handle lifecycle hooks (onCreated/onRendered/onDestroyed), manage Shadow DOM encapsulation and slot projection, implement settings vs state patterns, connect templates with reactive data context

ai/agents/domain/component/settings.json

@@ -0,0 +1,23 @@
+{
+  "permissions": {
+    "allow": [
+      "Read(packages/component/**)",
+      "Edit(packages/component/src/**)",
+      "Edit(packages/component/test/**)",
+      "Write(packages/component/src/**)",
+      "Write(packages/component/test/**)",
+      "MultiEdit(packages/component/src/**)",
+      "MultiEdit(packages/component/test/**)",
+      "Read(src/components/**)",
+      "Edit(src/components/**)",
+      "Write(src/components/**)",
+      "MultiEdit(src/components/**)",
+      "Read(docs/src/pages/api/component/**)",
+      "Read(docs/src/pages/components/**)",
+      "Read(ai/packages/component.md)"
+    ],
+    "deny": [],
+    "additionalDirectories": [],
+    "defaultMode": "default"
+  }
+}