@appiq/flutter-workflow 1.4.3 → 2.1.0

package/config/agent-coordination.json

@@ -0,0 +1,335 @@
+{
+  "agentOrchestration": {
+    "executionStrategy": "intelligent-parallel",
+    "maxParallelAgents": 3,
+    "coordinationProtocol": "event-driven",
+    "qualityGateEnforcement": true,
+    "crashRecoveryEnabled": true,
+    "statePreservationInterval": 300
+  },
+  "agentDefinitions": {
+    "po-agent": {
+      "name": "PO Agent (Phoenix)",
+      "role": "requirements-analysis",
+      "priority": 1,
+      "dependencies": [],
+      "parallelCompatible": false,
+      "avgDuration": "4-6 hours",
+      "qualityGates": ["requirements-completeness", "stakeholder-approval"],
+      "handoffRequirements": ["validated-requirements", "user-stories", "acceptance-criteria"]
+    },
+    "ui-agent": {
+      "name": "UI Agent (Aria)",
+      "role": "presentation-layer",
+      "priority": 2,
+      "dependencies": ["po-agent"],
+      "parallelCompatible": true,
+      "parallelGroup": "ui-domain",
+      "avgDuration": "8-12 hours",
+      "qualityGates": ["responsive-design", "accessibility", "performance"],
+      "handoffRequirements": ["ui-components", "responsive-layouts", "accessibility-validation"]
+    },
+    "domain-agent": {
+      "name": "Domain Agent (Atlas)",
+      "role": "business-logic",
+      "priority": 2,
+      "dependencies": ["po-agent"],
+      "parallelCompatible": true,
+      "parallelGroup": "ui-domain",
+      "avgDuration": "6-10 hours",
+      "qualityGates": ["clean-architecture", "business-rules", "domain-isolation"],
+      "handoffRequirements": ["domain-entities", "use-cases", "repository-interfaces"]
+    },
+    "cubit-agent": {
+      "name": "Cubit Agent (Sage)",
+      "role": "state-management",
+      "priority": 3,
+      "dependencies": ["ui-agent", "domain-agent"],
+      "parallelCompatible": false,
+      "avgDuration": "6-8 hours",
+      "qualityGates": ["state-architecture", "error-handling", "performance"],
+      "handoffRequirements": ["cubit-implementations", "state-persistence", "error-handling"]
+    },
+    "data-agent": {
+      "name": "Data Agent (Nova)",
+      "role": "data-layer",
+      "priority": 4,
+      "dependencies": ["cubit-agent"],
+      "parallelCompatible": false,
+      "avgDuration": "8-12 hours",
+      "qualityGates": ["repository-implementation", "api-integration", "offline-support"],
+      "handoffRequirements": ["repository-implementations", "api-integration", "caching-strategy"]
+    },
+    "security-agent": {
+      "name": "Security Agent (Guardian)",
+      "role": "security-compliance",
+      "priority": 5,
+      "dependencies": ["data-agent"],
+      "parallelCompatible": true,
+      "parallelGroup": "security-test",
+      "avgDuration": "4-6 hours",
+      "qualityGates": ["authentication", "coppa-compliance", "encryption", "vulnerability-assessment"],
+      "handoffRequirements": ["security-implementation", "coppa-validation", "audit-logs"]
+    },
+    "test-agent": {
+      "name": "Test Agent (Trinity)",
+      "role": "quality-assurance",
+      "priority": 5,
+      "dependencies": ["data-agent"],
+      "parallelCompatible": true,
+      "parallelGroup": "security-test",
+      "avgDuration": "10-15 hours",
+      "qualityGates": ["test-coverage", "performance-testing", "security-testing"],
+      "handoffRequirements": ["test-suite", "coverage-report", "performance-benchmarks"]
+    },
+    "integration-validator": {
+      "name": "Integration Validator",
+      "role": "system-integration",
+      "priority": 6,
+      "dependencies": ["security-agent", "test-agent"],
+      "parallelCompatible": false,
+      "avgDuration": "4-6 hours",
+      "qualityGates": ["system-integration", "deployment-readiness"],
+      "handoffRequirements": ["integration-validation", "deployment-package", "quality-certification"]
+    }
+  },
+  "parallelExecutionGroups": {
+    "ui-domain": {
+      "agents": ["ui-agent", "domain-agent"],
+      "description": "UI and Domain agents can work in parallel after PO completion",
+      "coordinationPoints": ["requirements-handoff", "architecture-alignment", "quality-validation"],
+      "sharedResources": ["feature-requirements", "architectural-decisions"],
+      "conflictResolution": "domain-priority"
+    },
+    "security-test": {
+      "agents": ["security-agent", "test-agent"],
+      "description": "Security and Test agents can work in parallel after data layer completion",
+      "coordinationPoints": ["data-layer-handoff", "security-test-alignment", "final-validation"],
+      "sharedResources": ["implementation-artifacts", "quality-metrics"],
+      "conflictResolution": "security-priority"
+    }
+  },
+  "qualityGateDefinitions": {
+    "requirements-completeness": {
+      "description": "All requirements documented and validated",
+      "criteria": ["user-stories-complete", "acceptance-criteria-defined", "technical-constraints-identified"],
+      "validator": "po-agent",
+      "automated": false,
+      "blockingLevel": "critical"
+    },
+    "stakeholder-approval": {
+      "description": "Stakeholder sign-off obtained",
+      "criteria": ["requirements-approved", "scope-confirmed", "timeline-accepted"],
+      "validator": "po-agent",
+      "automated": false,
+      "blockingLevel": "critical"
+    },
+    "responsive-design": {
+      "description": "UI works on all target screen sizes",
+      "criteria": ["mobile-responsive", "tablet-responsive", "desktop-responsive"],
+      "validator": "ui-agent",
+      "automated": true,
+      "blockingLevel": "major"
+    },
+    "accessibility": {
+      "description": "WCAG 2.1 AA compliance achieved",
+      "criteria": ["screen-reader-support", "keyboard-navigation", "color-contrast"],
+      "validator": "ui-agent",
+      "automated": true,
+      "blockingLevel": "major"
+    },
+    "clean-architecture": {
+      "description": "Clean Architecture principles followed",
+      "criteria": ["dependency-inversion", "single-responsibility", "domain-isolation"],
+      "validator": "domain-agent",
+      "automated": true,
+      "blockingLevel": "critical"
+    },
+    "state-architecture": {
+      "description": "State management properly implemented",
+      "criteria": ["cubit-pattern-compliance", "state-isolation", "event-handling"],
+      "validator": "cubit-agent",
+      "automated": true,
+      "blockingLevel": "major"
+    },
+    "repository-implementation": {
+      "description": "Repository pattern correctly implemented",
+      "criteria": ["interface-compliance", "error-handling", "caching-strategy"],
+      "validator": "data-agent",
+      "automated": true,
+      "blockingLevel": "major"
+    },
+    "coppa-compliance": {
+      "description": "COPPA compliance requirements met",
+      "criteria": ["child-privacy-protection", "data-minimization", "parental-consent"],
+      "validator": "security-agent",
+      "automated": false,
+      "blockingLevel": "critical"
+    },
+    "test-coverage": {
+      "description": "Minimum 90% test coverage achieved",
+      "criteria": ["unit-test-coverage", "widget-test-coverage", "integration-test-coverage"],
+      "validator": "test-agent",
+      "automated": true,
+      "blockingLevel": "major"
+    },
+    "system-integration": {
+      "description": "All components integrate properly",
+      "criteria": ["dependency-injection", "provider-hierarchy", "initialization"],
+      "validator": "integration-validator",
+      "automated": true,
+      "blockingLevel": "critical"
+    }
+  },
+  "workflowStates": {
+    "initialized": {
+      "description": "Feature initialized and ready for development",
+      "allowedTransitions": ["planning"],
+      "requiredActions": ["feature-analysis", "task-breakdown"]
+    },
+    "planning": {
+      "description": "Requirements analysis in progress",
+      "allowedTransitions": ["development"],
+      "requiredActions": ["po-agent-completion", "requirements-quality-gate"]
+    },
+    "development": {
+      "description": "Feature implementation in progress",
+      "allowedTransitions": ["integration", "blocked"],
+      "requiredActions": ["ui-completion", "domain-completion", "cubit-completion", "data-completion"]
+    },
+    "integration": {
+      "description": "Security, testing, and integration in progress",
+      "allowedTransitions": ["completed", "blocked"],
+      "requiredActions": ["security-completion", "test-completion", "integration-validation"]
+    },
+    "completed": {
+      "description": "Feature development completed and ready for deployment",
+      "allowedTransitions": ["deployed"],
+      "requiredActions": ["all-quality-gates-passed", "deployment-package-ready"]
+    },
+    "blocked": {
+      "description": "Development blocked by issues or dependencies",
+      "allowedTransitions": ["planning", "development", "integration"],
+      "requiredActions": ["blocker-resolution", "state-restoration"]
+    },
+    "deployed": {
+      "description": "Feature successfully deployed to production",
+      "allowedTransitions": [],
+      "requiredActions": ["deployment-verification", "monitoring-setup"]
+    }
+  },
+  "coordinationProtocols": {
+    "agent-handoff": {
+      "preHandoffChecks": [
+        "validate-current-agent-completion",
+        "run-quality-gates",
+        "prepare-handoff-materials",
+        "update-feature-state"
+      ],
+      "handoffActions": [
+        "transfer-context",
+        "activate-next-agent",
+        "log-handoff-event",
+        "start-progress-monitoring"
+      ],
+      "postHandoffValidation": [
+        "confirm-agent-activation",
+        "validate-context-transfer",
+        "monitor-initial-progress"
+      ]
+    },
+    "parallel-coordination": {
+      "preParallelActions": [
+        "validate-parallel-readiness",
+        "prepare-shared-context",
+        "setup-coordination-channels",
+        "define-merge-strategy"
+      ],
+      "parallelMonitoring": [
+        "monitor-agent-progress",
+        "detect-conflicts",
+        "coordinate-shared-resources",
+        "track-dependencies"
+      ],
+      "parallelCompletion": [
+        "validate-parallel-outputs",
+        "merge-results",
+        "resolve-conflicts",
+        "prepare-next-phase"
+      ]
+    },
+    "quality-gate-validation": {
+      "preValidation": [
+        "collect-validation-artifacts",
+        "prepare-test-environment",
+        "run-automated-checks"
+      ],
+      "validation": [
+        "execute-quality-criteria",
+        "collect-validation-results",
+        "assess-gate-status"
+      ],
+      "postValidation": [
+        "update-quality-status",
+        "log-validation-results",
+        "trigger-next-actions"
+      ]
+    }
+  },
+  "emergencyProcedures": {
+    "crashRecovery": {
+      "detectionMethods": ["heartbeat-monitoring", "progress-tracking", "error-detection"],
+      "recoverySteps": [
+        "detect-crash-condition",
+        "preserve-current-state",
+        "identify-recovery-point",
+        "restore-from-backup",
+        "validate-recovery",
+        "resume-execution"
+      ],
+      "preventionMeasures": ["continuous-state-backup", "checkpoint-creation", "redundancy-planning"]
+    },
+    "agentFailure": {
+      "detectionMethods": ["task-timeout", "error-reporting", "quality-gate-failure"],
+      "recoverySteps": [
+        "diagnose-failure-cause",
+        "assess-impact-scope",
+        "determine-recovery-strategy",
+        "execute-recovery-plan",
+        "validate-recovery-success"
+      ],
+      "escalationProcedure": ["retry-agent", "manual-intervention", "workflow-rollback"]
+    },
+    "qualityGateFailure": {
+      "detectionMethods": ["automated-validation", "manual-review", "stakeholder-feedback"],
+      "recoverySteps": [
+        "analyze-failure-criteria",
+        "identify-remediation-actions",
+        "execute-fixes",
+        "revalidate-quality-gate",
+        "document-lessons-learned"
+      ],
+      "preventionMeasures": ["early-validation", "continuous-monitoring", "incremental-quality-checks"]
+    }
+  },
+  "performanceOptimization": {
+    "parallelization": {
+      "maxParallelAgents": 3,
+      "resourceAllocation": "balanced",
+      "conflictResolution": "priority-based",
+      "loadBalancing": "dynamic"
+    },
+    "caching": {
+      "agentOutputCaching": true,
+      "templateCaching": true,
+      "stateCaching": true,
+      "cacheTTL": 3600
+    },
+    "monitoring": {
+      "agentPerformanceMetrics": true,
+      "workflowTimingAnalysis": true,
+      "resourceUtilizationTracking": true,
+      "qualityMetrics": true
+    }
+  }
+}

package/config/independent-mode-template.md

@@ -0,0 +1,202 @@
+# Universal Independent Agent Mode Template
+
+This template can be added to any AppIQ agent to enable Independent Mode operation.
+
+## Context-Aware Operation Mode
+
+**INDEPENDENT MODE** (User calls you directly for specific tasks):
+1. Introduce yourself: "🎯 Hi! I'm {AGENT_NAME}, your {AGENT_SPECIALTY}. I can work independently or as part of the full workflow. I specialize in {AGENT_SKILLS}. How can I help you with {AGENT_DOMAIN} today?"
+2. **Detect existing features**: Check `docs/features/` for related features to update
+3. **Offer options**: 
+   - "🆕 Create new standalone {AGENT_DELIVERABLE}"
+   - "🔄 Improve existing feature {AGENT_DOMAIN} (I'll find and update the right feature)"
+   - "🏗️ Start new feature (I'll coordinate with FeatureMaster)"
+4. **Initialize tracking**: Set up lightweight progress tracking and history logging
+5. **Work collaboratively**: Get user requirements and implement with full documentation
+
+**WORKFLOW ACTIVATION** (Called by FeatureMaster or other agents):
+1. Start directly with requirements from the workflow
+2. Use specifications provided by previous agent (PO/FeatureMaster)
+3. Focus on implementation without interactive discussion
+4. Update feature state and coordinate with workflow system
+
+## Independent Agent Commands
+
+When working in **Independent Mode**, you have these specialized commands:
+
+### **Feature Detection & Integration:**
+- `*find-related-feature {description}` - Search existing features that might be related to the task
+- `*update-feature-{AGENT_DOMAIN} {featureName}` - Update {AGENT_DOMAIN} for existing feature with progress tracking
+- `*create-standalone-{AGENT_DELIVERABLE} {name}` - Create {AGENT_DELIVERABLE} outside feature workflow
+- `*suggest-feature-creation {description}` - Recommend creating new feature and coordinate with FeatureMaster
+
+### **Lightweight Tracking:**
+- `*start-{AGENT_DOMAIN}-session {taskDescription}` - Initialize independent session with tracking
+- `*log-{AGENT_DOMAIN}-progress {activity}` - Log current work for history and collaboration
+- `*update-{AGENT_DOMAIN}-status {status}` - Update current status (analyzing/implementing/testing/completed)
+- `*create-{AGENT_DOMAIN}-summary` - Generate summary of work done and next steps
+
+### **Quality & Integration:**
+- `*validate-{AGENT_DOMAIN}-quality` - Run quality checks specific to agent domain
+- `*check-{AGENT_DOMAIN}-consistency` - Validate against existing patterns and standards
+- `*prepare-handoff {toAgent?}` - Prepare work for handoff to another agent if needed
+
+### **Collaboration Commands:**
+- `*request-feedback` - Request user feedback on current implementation
+- `*coordinate-with-agents {agentList}` - Coordinate with other agents if broader changes needed
+- `*escalate-to-workflow {reason}` - Escalate to full feature workflow if complexity requires it
+
+## Independent Mode Implementation Protocol
+
+When operating in **Independent Mode**, follow this workflow:
+
+### **Phase 1: Initialization & Detection**
+1. **Welcome & Capability Overview**: 
+   - Greet user and explain independent vs workflow modes
+   - Show available options for {AGENT_DOMAIN} work
+
+2. **Context Detection**:
+   ```javascript
+   const tracker = new IndependentAgentTracker();
+   const session = await tracker.startIndependentSession(
+     '{AGENT_ID}', 
+     userTaskDescription, 
+     relatedFeature
+   );
+   ```
+
+3. **Feature Discovery**:
+   - Execute `*find-related-feature {userDescription}`
+   - Present options: Update existing feature, create standalone, or start new feature
+   - Let user choose approach
+
+### **Phase 2: Requirements & Planning**
+1. **Detailed Requirements Gathering**:
+   - Ask specific questions about {AGENT_DOMAIN} needs
+   - Understand constraints and preferences
+   - Identify dependencies and integrations
+   - Assess quality and performance requirements
+
+2. **Codebase Analysis** (Mandatory):
+   - Analyze existing {AGENT_DOMAIN} patterns
+   - Check for reusable components/patterns
+   - Validate consistency with existing architecture
+   - Identify potential conflicts or dependencies
+
+3. **Planning & Estimation**:
+   ```javascript
+   await tracker.logActivity(sessionId, 'requirements_gathered', {
+     description: 'Completed requirements analysis',
+     requirements: detailedRequirements,
+     estimatedDuration: estimatedTime
+   });
+   ```
+
+### **Phase 3: Implementation**
+1. **Progressive Implementation**:
+   - Start with core {AGENT_DELIVERABLE} structure
+   - Add {AGENT_SPECIFIC_FEATURES}
+   - Implement quality measures
+   - Add documentation and examples
+
+2. **Continuous Tracking**:
+   ```javascript
+   // Update progress as you work
+   await tracker.updateProgress(sessionId, progressPercent, 'implementing', currentActivity);
+   await tracker.logActivity(sessionId, 'implementation_milestone', {
+     description: 'Completed {SPECIFIC_MILESTONE}',
+     files: createdFiles,
+     deliverables: completedDeliverables
+   });
+   ```
+
+3. **Quality Validation**:
+   - Execute `*validate-{AGENT_DOMAIN}-quality` at regular intervals
+   - Test {AGENT_SPECIFIC_QUALITY_CHECKS}
+   - Verify {AGENT_COMPLIANCE_REQUIREMENTS}
+   - Validate performance and integration
+
+### **Phase 4: Integration & Completion**
+1. **Integration Choice**:
+   - If related to existing feature: Execute `*update-feature-{AGENT_DOMAIN} {featureName}`
+   - If standalone: Execute `*create-standalone-{AGENT_DELIVERABLE} {name}`
+   - If complex: Execute `*escalate-to-workflow {reason}`
+
+2. **Documentation & Handoff**:
+   ```javascript
+   await tracker.logActivity(sessionId, 'documentation_created', {
+     description: 'Created {AGENT_DOMAIN} documentation and usage examples',
+     deliverables: deliverablesList
+   });
+   ```
+
+3. **Session Completion**:
+   ```javascript
+   await tracker.completeSession(sessionId, `
+   Completed {AGENT_DOMAIN} implementation for: ${taskDescription}
+   
+   Deliverables:
+   - {AGENT_SPECIFIC_DELIVERABLES}
+   
+   Quality Validations:
+   - {AGENT_QUALITY_CONFIRMATIONS}
+   
+   Next steps: ${nextSteps}
+   `);
+   ```
+
+### **Continuous Quality Gates**
+- **After Requirements**: Validate completeness and clarity
+- **During Implementation**: Check {AGENT_DOMAIN} consistency and quality
+- **Before Completion**: Run full {AGENT_DOMAIN} validation suite
+- **Post-Implementation**: Verify integration and documentation
+
+### **Escalation Triggers**
+Automatically escalate to full workflow if:
+- {AGENT_SPECIFIC_ESCALATION_TRIGGERS}
+- Cross-domain changes are required
+- User requests full feature development
+- Complexity exceeds independent scope
+
+### **Collaboration Patterns**
+- **With {RELATED_AGENTS}**: {COLLABORATION_SCENARIOS}
+- **With FeatureMaster**: For workflow coordination and escalation
+
+## Agent-Specific Customization
+
+Replace these placeholders with agent-specific values:
+
+- `{AGENT_NAME}`: Human-friendly agent name (e.g., "Maya", "Alex")
+- `{AGENT_SPECIALTY}`: Agent specialization (e.g., "Flutter UI/UX Design Specialist")
+- `{AGENT_SKILLS}`: Key skills and capabilities
+- `{AGENT_DOMAIN}`: Primary domain (e.g., "ui", "state", "domain", "data")
+- `{AGENT_DELIVERABLE}`: Main deliverable type (e.g., "component", "cubit", "entity")
+- `{AGENT_ID}`: Technical agent identifier (e.g., "ui-agent", "cubit-agent")
+- `{AGENT_SPECIFIC_FEATURES}`: Domain-specific implementation features
+- `{AGENT_SPECIFIC_QUALITY_CHECKS}`: Domain-specific quality validations
+- `{AGENT_COMPLIANCE_REQUIREMENTS}`: Domain-specific compliance requirements
+- `{AGENT_SPECIFIC_DELIVERABLES}`: Domain-specific deliverable list
+- `{AGENT_QUALITY_CONFIRMATIONS}`: Domain-specific quality confirmations
+- `{AGENT_SPECIFIC_ESCALATION_TRIGGERS}`: Domain-specific escalation conditions
+- `{RELATED_AGENTS}`: Agents this agent commonly collaborates with
+- `{COLLABORATION_SCENARIOS}`: Common collaboration scenarios
+
+## Example Agent Customizations
+
+### UI Agent Example:
+- `{AGENT_DOMAIN}`: "ui"
+- `{AGENT_DELIVERABLE}`: "component"
+- `{AGENT_SPECIFIC_FEATURES}`: "platform-adaptive elements, responsive design, animations"
+- `{AGENT_SPECIFIC_QUALITY_CHECKS}`: "responsiveness across screen sizes, accessibility compliance"
+
+### Cubit Agent Example:
+- `{AGENT_DOMAIN}`: "state"
+- `{AGENT_DELIVERABLE}`: "cubit"
+- `{AGENT_SPECIFIC_FEATURES}`: "state management, event handling, business logic integration"
+- `{AGENT_SPECIFIC_QUALITY_CHECKS}`: "state isolation, performance optimization, error handling"
+
+### Domain Agent Example:
+- `{AGENT_DOMAIN}`: "domain"
+- `{AGENT_DELIVERABLE}`: "entity"
+- `{AGENT_SPECIFIC_FEATURES}`: "business entities, use cases, repository interfaces"
+- `{AGENT_SPECIFIC_QUALITY_CHECKS}`: "Clean Architecture compliance, business rule validation"