gkt-node 3.3.0

package/assets/.agent/skills/claude-code-guide/SKILL.md

@@ -0,0 +1,68 @@
+---
+name: Claude Code Guide
+description: Master guide for using Claude Code effectively. Includes configuration templates, prompting strategies "Thinking" keywords, debugging techniques, and best practices for interacting with the agent.
+---
+
+# Claude Code Guide
+
+## Purpose
+
+To provide a comprehensive reference for configuring and using Claude Code (the agentic coding tool) to its full potential. This skill synthesizes best practices, configuration templates, and advanced usage patterns.
+
+## Configuration (`CLAUDE.md`)
+
+When starting a new project, create a `CLAUDE.md` file in the root directory to guide the agent.
+
+### Template (General)
+
+```markdown
+# Project Guidelines
+
+## Commands
+
+- Run app: `npm run dev`
+- Test: `npm test`
+- Build: `npm run build`
+
+## Code Style
+
+- Use TypeScript for all new code.
+- Functional components with Hooks for React.
+- Tailwind CSS for styling.
+- Early returns for error handling.
+
+## Workflow
+
+- Read `README.md` first to understand project context.
+- Before editing, read the file content.
+- After editing, run tests to verify.
+```
+
+## Advanced Features
+
+### Thinking Keywords
+
+Use these keywords in your prompts to trigger deeper reasoning from the agent:
+
+- "Think step-by-step"
+- "Analyze the root cause"
+- "Plan before executing"
+- "Verify your assumptions"
+
+### Debugging
+
+If the agent is stuck or behaving unexpectedly:
+
+1. **Clear Context**: Start a new session or ask the agent to "forget previous instructions" if confused.
+2. **Explicit Instructions**: Be extremely specific about paths, filenames, and desired outcomes.
+3. **Logs**: Ask the agent to "check the logs" or "run the command with verbose output".
+
+## Best Practices
+
+1. **Small Contexts**: Don't dump the entire codebase into the context. Use `grep` or `find` to locate relevant files first.
+2. **Iterative Development**: Ask for small changes, verify, then proceed.
+3. **Feedback Loop**: If the agent makes a mistake, correct it immediately and ask it to "add a lesson" to its memory (if supported) or `CLAUDE.md`.
+
+## Reference
+
+Based on [Claude Code Guide by zebbern](https://github.com/zebbern/claude-code-guide).

package/assets/.agent/skills/clean-code/SKILL.md

@@ -0,0 +1,94 @@
+---
+name: clean-code
+description: "Applies principles from Robert C. Martin's 'Clean Code'. Use this skill when writing, reviewing, or refactoring code to ensure high quality, readability, and maintainability. Covers naming, functions, comments, error handling, and class design."
+user-invocable: true
+risk: safe
+source: "ClawForge (https://github.com/jackjin1997/ClawForge)"
+---
+
+# Clean Code Skill
+
+This skill embodies the principles of "Clean Code" by Robert C. Martin (Uncle Bob). Use it to transform "code that works" into "code that is clean."
+
+## 🧠 Core Philosophy
+> "Code is clean if it can be read, and enhanced by a developer other than its original author." — Grady Booch
+
+## When to Use
+Use this skill when:
+- **Writing new code**: To ensure high quality from the start.
+- **Reviewing Pull Requests**: To provide constructive, principle-based feedback.
+- **Refactoring legacy code**: To identify and remove code smells.
+- **Improving team standards**: To align on industry-standard best practices.
+
+## 1. Meaningful Names
+- **Use Intention-Revealing Names**: `elapsedTimeInDays` instead of `d`.
+- **Avoid Disinformation**: Don't use `accountList` if it's actually a `Map`.
+- **Make Meaningful Distinctions**: Avoid `ProductData` vs `ProductInfo`.
+- **Use Pronounceable/Searchable Names**: Avoid `genymdhms`.
+- **Class Names**: Use nouns (`Customer`, `WikiPage`). Avoid `Manager`, `Data`.
+- **Method Names**: Use verbs (`postPayment`, `deletePage`).
+
+## 2. Functions
+- **Small!**: Functions should be shorter than you think.
+- **Do One Thing**: A function should do only one thing, and do it well.
+- **One Level of Abstraction**: Don't mix high-level business logic with low-level details (like regex).
+- **Descriptive Names**: `isPasswordValid` is better than `check`.
+- **Arguments**: 0 is ideal, 1-2 is okay, 3+ requires a very strong justification.
+- **No Side Effects**: Functions shouldn't secretly change global state.
+
+## 3. Comments
+- **Don't Comment Bad Code—Rewrite It**: Most comments are a sign of failure to express ourselves in code.
+- **Explain Yourself in Code**: 
+  ```python
+  # Check if employee is eligible for full benefits
+  if employee.flags & HOURLY and employee.age > 65:
+  ```
+  vs
+  ```python
+  if employee.isEligibleForFullBenefits():
+  ```
+- **Good Comments**: Legal, Informative (regex intent), Clarification (external libraries), TODOs.
+- **Bad Comments**: Mumbling, Redundant, Misleading, Mandated, Noise, Position Markers.
+
+## 4. Formatting
+- **The Newspaper Metaphor**: High-level concepts at the top, details at the bottom.
+- **Vertical Density**: Related lines should be close to each other.
+- **Distance**: Variables should be declared near their usage.
+- **Indentation**: Essential for structural readability.
+
+## 5. Objects and Data Structures
+- **Data Abstraction**: Hide the implementation behind interfaces.
+- **The Law of Demeter**: A module should not know about the innards of the objects it manipulates. Avoid `a.getB().getC().doSomething()`.
+- **Data Transfer Objects (DTO)**: Classes with public variables and no functions.
+
+## 6. Error Handling
+- **Use Exceptions instead of Return Codes**: Keeps logic clean.
+- **Write Try-Catch-Finally First**: Defines the scope of the operation.
+- **Don't Return Null**: It forces the caller to check for null every time.
+- **Don't Pass Null**: Leads to `NullPointerException`.
+
+## 7. Unit Tests
+- **The Three Laws of TDD**:
+  1. Don't write production code until you have a failing unit test.
+  2. Don't write more of a unit test than is sufficient to fail.
+  3. Don't write more production code than is sufficient to pass the failing test.
+- **F.I.R.S.T. Principles**: Fast, Independent, Repeatable, Self-Validating, Timely.
+
+## 8. Classes
+- **Small!**: Classes should have a single responsibility (SRP).
+- **The Stepdown Rule**: We want the code to read like a top-down narrative.
+
+## 9. Smells and Heuristics
+- **Rigidity**: Hard to change.
+- **Fragility**: Breaks in many places.
+- **Immobility**: Hard to reuse.
+- **Viscosity**: Hard to do the right thing.
+- **Needless Complexity/Repetition**.
+
+## 🛠️ Implementation Checklist
+- [ ] Is this function smaller than 20 lines?
+- [ ] Does this function do exactly one thing?
+- [ ] Are all names searchable and intention-revealing?
+- [ ] Have I avoided comments by making the code clearer?
+- [ ] Am I passing too many arguments?
+- [ ] Is there a failing test for this change?

package/assets/.agent/skills/clickup-automation/SKILL.md

@@ -0,0 +1,234 @@
+---
+name: clickup-automation
+description: "Automate ClickUp project management including tasks, spaces, folders, lists, comments, and team operations via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# ClickUp Automation via Rube MCP
+
+Automate ClickUp project management workflows including task creation and updates, workspace hierarchy navigation, comments, and team member management through Composio's ClickUp toolkit.
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active ClickUp connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `clickup`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `clickup`
+3. If connection is not ACTIVE, follow the returned auth link to complete ClickUp OAuth
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Core Workflows
+
+### 1. Create and Manage Tasks
+
+**When to use**: User wants to create tasks, subtasks, update task properties, or list tasks in a ClickUp list.
+
+**Tool sequence**:
+1. `CLICKUP_GET_AUTHORIZED_TEAMS_WORKSPACES` - Get workspace/team IDs [Prerequisite]
+2. `CLICKUP_GET_SPACES` - List spaces in the workspace [Prerequisite]
+3. `CLICKUP_GET_FOLDERS` - List folders in a space [Prerequisite]
+4. `CLICKUP_GET_FOLDERLESS_LISTS` - Get lists not inside folders [Optional]
+5. `CLICKUP_GET_LIST` - Validate list and check available statuses [Prerequisite]
+6. `CLICKUP_CREATE_TASK` - Create a task in the target list [Required]
+7. `CLICKUP_CREATE_TASK` (with `parent`) - Create subtask under a parent task [Optional]
+8. `CLICKUP_UPDATE_TASK` - Modify task status, assignees, dates, priority [Optional]
+9. `CLICKUP_GET_TASK` - Retrieve full task details [Optional]
+10. `CLICKUP_GET_TASKS` - List all tasks in a list with filters [Optional]
+11. `CLICKUP_DELETE_TASK` - Permanently remove a task [Optional]
+
+**Key parameters for CLICKUP_CREATE_TASK**:
+- `list_id`: Target list ID (integer, required)
+- `name`: Task name (string, required)
+- `description`: Detailed task description
+- `status`: Must exactly match (case-sensitive) a status name configured in the target list
+- `priority`: 1 (Urgent), 2 (High), 3 (Normal), 4 (Low)
+- `assignees`: Array of user IDs (integers)
+- `due_date`: Unix timestamp in milliseconds
+- `parent`: Parent task ID string for creating subtasks
+- `tags`: Array of tag name strings
+- `time_estimate`: Estimated time in milliseconds
+
+**Pitfalls**:
+- `status` is case-sensitive and must match an existing status in the list; use `CLICKUP_GET_LIST` to check available statuses
+- `due_date` and `start_date` are Unix timestamps in **milliseconds**, not seconds
+- Subtask `parent` must be a task (not another subtask) in the same list
+- `notify_all` triggers watcher notifications; set to false for bulk operations
+- Retries can create duplicates; track created task IDs to avoid re-creation
+- `custom_item_id` for milestones (ID 1) is subject to workspace plan quotas
+
+### 2. Navigate Workspace Hierarchy
+
+**When to use**: User wants to browse or manage the ClickUp workspace structure (Workspaces > Spaces > Folders > Lists).
+
+**Tool sequence**:
+1. `CLICKUP_GET_AUTHORIZED_TEAMS_WORKSPACES` - List all accessible workspaces [Required]
+2. `CLICKUP_GET_SPACES` - List spaces within a workspace [Required]
+3. `CLICKUP_GET_SPACE` - Get details for a specific space [Optional]
+4. `CLICKUP_GET_FOLDERS` - List folders in a space [Required]
+5. `CLICKUP_GET_FOLDER` - Get details for a specific folder [Optional]
+6. `CLICKUP_CREATE_FOLDER` - Create a new folder in a space [Optional]
+7. `CLICKUP_GET_FOLDERLESS_LISTS` - List lists not inside any folder [Required]
+8. `CLICKUP_GET_LIST` - Get list details including statuses and custom fields [Optional]
+
+**Key parameters**:
+- `team_id`: Workspace ID from GET_AUTHORIZED_TEAMS_WORKSPACES (required for spaces)
+- `space_id`: Space ID (required for folders and folderless lists)
+- `folder_id`: Folder ID (required for GET_FOLDER)
+- `list_id`: List ID (required for GET_LIST)
+- `archived`: Boolean filter for archived/active items
+
+**Pitfalls**:
+- ClickUp hierarchy is: Workspace (Team) > Space > Folder > List > Task
+- Lists can exist directly under Spaces (folderless) or inside Folders
+- Must use `CLICKUP_GET_FOLDERLESS_LISTS` to find lists not inside folders; `CLICKUP_GET_FOLDERS` only returns folders
+- `team_id` in ClickUp API refers to the Workspace ID, not a user group
+
+### 3. Add Comments to Tasks
+
+**When to use**: User wants to add comments, review existing comments, or manage comment threads on tasks.
+
+**Tool sequence**:
+1. `CLICKUP_GET_TASK` - Verify task exists and get task_id [Prerequisite]
+2. `CLICKUP_CREATE_TASK_COMMENT` - Add a new comment to the task [Required]
+3. `CLICKUP_GET_TASK_COMMENTS` - List existing comments on the task [Optional]
+4. `CLICKUP_UPDATE_COMMENT` - Edit comment text, assignee, or resolution status [Optional]
+
+**Key parameters for CLICKUP_CREATE_TASK_COMMENT**:
+- `task_id`: Task ID string (required)
+- `comment_text`: Comment content with ClickUp formatting support (required)
+- `assignee`: User ID to assign the comment to (required)
+- `notify_all`: true/false for watcher notifications (required)
+
+**Key parameters for CLICKUP_GET_TASK_COMMENTS**:
+- `task_id`: Task ID string (required)
+- `start` / `start_id`: Pagination for older comments (max 25 per page)
+
+**Pitfalls**:
+- `CLICKUP_CREATE_TASK_COMMENT` requires all four fields: `task_id`, `comment_text`, `assignee`, and `notify_all`
+- `assignee` on a comment assigns the comment (not the task) to that user
+- Comments are paginated at 25 per page; use `start` (Unix ms) and `start_id` for older pages
+- `CLICKUP_UPDATE_COMMENT` requires all four fields: `comment_id`, `comment_text`, `assignee`, `resolved`
+
+### 4. Manage Team Members and Assignments
+
+**When to use**: User wants to view workspace members, check seat utilization, or look up user details.
+
+**Tool sequence**:
+1. `CLICKUP_GET_AUTHORIZED_TEAMS_WORKSPACES` - List workspaces and get team_id [Required]
+2. `CLICKUP_GET_WORKSPACE_SEATS` - Check seat utilization (members vs guests) [Required]
+3. `CLICKUP_GET_TEAMS` - List user groups within the workspace [Optional]
+4. `CLICKUP_GET_USER` - Get details for a specific user (Enterprise only) [Optional]
+5. `CLICKUP_GET_CUSTOM_ROLES` - List custom permission roles [Optional]
+
+**Key parameters**:
+- `team_id`: Workspace ID (required for all team operations)
+- `user_id`: Specific user ID for GET_USER
+- `group_ids`: Comma-separated group IDs to filter teams
+
+**Pitfalls**:
+- `CLICKUP_GET_WORKSPACE_SEATS` returns seat counts, not member details; distinguish members from guests
+- `CLICKUP_GET_TEAMS` returns user groups, not workspace members; empty groups does not mean no members
+- `CLICKUP_GET_USER` is only available on ClickUp Enterprise Plan
+- Must repeat workspace seat queries for each workspace in multi-workspace setups
+
+### 5. Filter and Query Tasks
+
+**When to use**: User wants to find tasks with specific filters (status, assignee, dates, tags, custom fields).
+
+**Tool sequence**:
+1. `CLICKUP_GET_TASKS` - Filter tasks in a list with multiple criteria [Required]
+2. `CLICKUP_GET_TASK` - Get full details for individual tasks [Optional]
+
+**Key parameters for CLICKUP_GET_TASKS**:
+- `list_id`: List ID (integer, required)
+- `statuses`: Array of status strings to filter by
+- `assignees`: Array of user ID strings
+- `tags`: Array of tag name strings
+- `due_date_gt` / `due_date_lt`: Unix timestamp in ms for date range
+- `include_closed`: Boolean to include closed tasks
+- `subtasks`: Boolean to include subtasks
+- `order_by`: "id", "created", "updated", or "due_date"
+- `page`: Page number starting at 0 (max 100 tasks per page)
+
+**Pitfalls**:
+- Only tasks whose home list matches `list_id` are returned; tasks in sublists are not included
+- Date filters use Unix timestamps in milliseconds
+- Status strings must match exactly; use URL encoding for spaces (e.g., "to%20do")
+- Page numbering starts at 0; each page returns up to 100 tasks
+- `custom_fields` filter accepts an array of JSON strings, not objects
+
+## Common Patterns
+
+### ID Resolution
+Always resolve names to IDs through the hierarchy:
+- **Workspace name -> team_id**: `CLICKUP_GET_AUTHORIZED_TEAMS_WORKSPACES` and match by name
+- **Space name -> space_id**: `CLICKUP_GET_SPACES` with `team_id`
+- **Folder name -> folder_id**: `CLICKUP_GET_FOLDERS` with `space_id`
+- **List name -> list_id**: Navigate folders or use `CLICKUP_GET_FOLDERLESS_LISTS`
+- **Task name -> task_id**: `CLICKUP_GET_TASKS` with `list_id` and match by name
+
+### Pagination
+- `CLICKUP_GET_TASKS`: Page-based with `page` starting at 0, max 100 tasks per page
+- `CLICKUP_GET_TASK_COMMENTS`: Uses `start` (Unix ms) and `start_id` for cursor-based paging, max 25 per page
+- Continue fetching until response returns fewer items than the page size
+
+## Known Pitfalls
+
+### ID Formats
+- Workspace/Team IDs are large integers
+- Space, folder, and list IDs are integers
+- Task IDs are alphanumeric strings (e.g., "9hz", "abc123")
+- User IDs are integers
+- Comment IDs are integers
+
+### Rate Limits
+- ClickUp enforces rate limits; bulk task creation can trigger 429 responses
+- Honor `Retry-After` header when present
+- Set `notify_all=false` for bulk operations to reduce notification load
+
+### Parameter Quirks
+- `team_id` in the API means Workspace ID, not a user group
+- `status` on tasks is case-sensitive and list-specific
+- Dates are Unix timestamps in **milliseconds** (multiply seconds by 1000)
+- `priority` is an integer 1-4 (1=Urgent, 4=Low), not a string
+- `CLICKUP_CREATE_TASK_COMMENT` marks `assignee` and `notify_all` as required
+- To clear a task description, pass a single space `" "` to `CLICKUP_UPDATE_TASK`
+
+### Hierarchy Rules
+- Subtask parent must not itself be a subtask
+- Subtask parent must be in the same list
+- Lists can be folderless (directly in a Space) or inside a Folder
+- Subitem boards are not supported by CLICKUP_CREATE_TASK
+
+## Quick Reference
+
+| Task | Tool Slug | Key Params |
+|------|-----------|------------|
+| List workspaces | `CLICKUP_GET_AUTHORIZED_TEAMS_WORKSPACES` | (none) |
+| List spaces | `CLICKUP_GET_SPACES` | `team_id` |
+| Get space details | `CLICKUP_GET_SPACE` | `space_id` |
+| List folders | `CLICKUP_GET_FOLDERS` | `space_id` |
+| Get folder details | `CLICKUP_GET_FOLDER` | `folder_id` |
+| Create folder | `CLICKUP_CREATE_FOLDER` | `space_id`, `name` |
+| Folderless lists | `CLICKUP_GET_FOLDERLESS_LISTS` | `space_id` |
+| Get list details | `CLICKUP_GET_LIST` | `list_id` |
+| Create task | `CLICKUP_CREATE_TASK` | `list_id`, `name`, `status`, `assignees` |
+| Update task | `CLICKUP_UPDATE_TASK` | `task_id`, `status`, `priority` |
+| Get task | `CLICKUP_GET_TASK` | `task_id`, `include_subtasks` |
+| List tasks | `CLICKUP_GET_TASKS` | `list_id`, `statuses`, `page` |
+| Delete task | `CLICKUP_DELETE_TASK` | `task_id` |
+| Add comment | `CLICKUP_CREATE_TASK_COMMENT` | `task_id`, `comment_text`, `assignee` |
+| List comments | `CLICKUP_GET_TASK_COMMENTS` | `task_id`, `start`, `start_id` |
+| Update comment | `CLICKUP_UPDATE_COMMENT` | `comment_id`, `comment_text`, `resolved` |
+| Workspace seats | `CLICKUP_GET_WORKSPACE_SEATS` | `team_id` |
+| List user groups | `CLICKUP_GET_TEAMS` | `team_id` |
+| Get user details | `CLICKUP_GET_USER` | `team_id`, `user_id` |
+| Custom roles | `CLICKUP_GET_CUSTOM_ROLES` | `team_id` |

package/assets/.agent/skills/cloud-architect/SKILL.md

@@ -0,0 +1,135 @@
+---
+name: cloud-architect
+description: Expert cloud architect specializing in AWS/Azure/GCP multi-cloud
+  infrastructure design, advanced IaC (Terraform/OpenTofu/CDK), FinOps cost
+  optimization, and modern architectural patterns. Masters serverless,
+  microservices, security, compliance, and disaster recovery. Use PROACTIVELY
+  for cloud architecture, cost optimization, migration planning, or multi-cloud
+  strategies.
+metadata:
+  model: opus
+---
+
+## Use this skill when
+
+- Working on cloud architect tasks or workflows
+- Needing guidance, best practices, or checklists for cloud architect
+
+## Do not use this skill when
+
+- The task is unrelated to cloud architect
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+You are a cloud architect specializing in scalable, cost-effective, and secure multi-cloud infrastructure design.
+
+## Purpose
+Expert cloud architect with deep knowledge of AWS, Azure, GCP, and emerging cloud technologies. Masters Infrastructure as Code, FinOps practices, and modern architectural patterns including serverless, microservices, and event-driven architectures. Specializes in cost optimization, security best practices, and building resilient, scalable systems.
+
+## Capabilities
+
+### Cloud Platform Expertise
+- **AWS**: EC2, Lambda, EKS, RDS, S3, VPC, IAM, CloudFormation, CDK, Well-Architected Framework
+- **Azure**: Virtual Machines, Functions, AKS, SQL Database, Blob Storage, Virtual Network, ARM templates, Bicep
+- **Google Cloud**: Compute Engine, Cloud Functions, GKE, Cloud SQL, Cloud Storage, VPC, Cloud Deployment Manager
+- **Multi-cloud strategies**: Cross-cloud networking, data replication, disaster recovery, vendor lock-in mitigation
+- **Edge computing**: CloudFlare, AWS CloudFront, Azure CDN, edge functions, IoT architectures
+
+### Infrastructure as Code Mastery
+- **Terraform/OpenTofu**: Advanced module design, state management, workspaces, provider configurations
+- **Native IaC**: CloudFormation (AWS), ARM/Bicep (Azure), Cloud Deployment Manager (GCP)
+- **Modern IaC**: AWS CDK, Azure CDK, Pulumi with TypeScript/Python/Go
+- **GitOps**: Infrastructure automation with ArgoCD, Flux, GitHub Actions, GitLab CI/CD
+- **Policy as Code**: Open Policy Agent (OPA), AWS Config, Azure Policy, GCP Organization Policy
+
+### Cost Optimization & FinOps
+- **Cost monitoring**: CloudWatch, Azure Cost Management, GCP Cost Management, third-party tools (CloudHealth, Cloudability)
+- **Resource optimization**: Right-sizing recommendations, reserved instances, spot instances, committed use discounts
+- **Cost allocation**: Tagging strategies, chargeback models, showback reporting
+- **FinOps practices**: Cost anomaly detection, budget alerts, optimization automation
+- **Multi-cloud cost analysis**: Cross-provider cost comparison, TCO modeling
+
+### Architecture Patterns
+- **Microservices**: Service mesh (Istio, Linkerd), API gateways, service discovery
+- **Serverless**: Function composition, event-driven architectures, cold start optimization
+- **Event-driven**: Message queues, event streaming (Kafka, Kinesis, Event Hubs), CQRS/Event Sourcing
+- **Data architectures**: Data lakes, data warehouses, ETL/ELT pipelines, real-time analytics
+- **AI/ML platforms**: Model serving, MLOps, data pipelines, GPU optimization
+
+### Security & Compliance
+- **Zero-trust architecture**: Identity-based access, network segmentation, encryption everywhere
+- **IAM best practices**: Role-based access, service accounts, cross-account access patterns
+- **Compliance frameworks**: SOC2, HIPAA, PCI-DSS, GDPR, FedRAMP compliance architectures
+- **Security automation**: SAST/DAST integration, infrastructure security scanning
+- **Secrets management**: HashiCorp Vault, cloud-native secret stores, rotation strategies
+
+### Scalability & Performance
+- **Auto-scaling**: Horizontal/vertical scaling, predictive scaling, custom metrics
+- **Load balancing**: Application load balancers, network load balancers, global load balancing
+- **Caching strategies**: CDN, Redis, Memcached, application-level caching
+- **Database scaling**: Read replicas, sharding, connection pooling, database migration
+- **Performance monitoring**: APM tools, synthetic monitoring, real user monitoring
+
+### Disaster Recovery & Business Continuity
+- **Multi-region strategies**: Active-active, active-passive, cross-region replication
+- **Backup strategies**: Point-in-time recovery, cross-region backups, backup automation
+- **RPO/RTO planning**: Recovery time objectives, recovery point objectives, DR testing
+- **Chaos engineering**: Fault injection, resilience testing, failure scenario planning
+
+### Modern DevOps Integration
+- **CI/CD pipelines**: GitHub Actions, GitLab CI, Azure DevOps, AWS CodePipeline
+- **Container orchestration**: EKS, AKS, GKE, self-managed Kubernetes
+- **Observability**: Prometheus, Grafana, DataDog, New Relic, OpenTelemetry
+- **Infrastructure testing**: Terratest, InSpec, Checkov, Terrascan
+
+### Emerging Technologies
+- **Cloud-native technologies**: CNCF landscape, service mesh, Kubernetes operators
+- **Edge computing**: Edge functions, IoT gateways, 5G integration
+- **Quantum computing**: Cloud quantum services, hybrid quantum-classical architectures
+- **Sustainability**: Carbon footprint optimization, green cloud practices
+
+## Behavioral Traits
+- Emphasizes cost-conscious design without sacrificing performance or security
+- Advocates for automation and Infrastructure as Code for all infrastructure changes
+- Designs for failure with multi-AZ/region resilience and graceful degradation
+- Implements security by default with least privilege access and defense in depth
+- Prioritizes observability and monitoring for proactive issue detection
+- Considers vendor lock-in implications and designs for portability when beneficial
+- Stays current with cloud provider updates and emerging architectural patterns
+- Values simplicity and maintainability over complexity
+
+## Knowledge Base
+- AWS, Azure, GCP service catalogs and pricing models
+- Cloud provider security best practices and compliance standards
+- Infrastructure as Code tools and best practices
+- FinOps methodologies and cost optimization strategies
+- Modern architectural patterns and design principles
+- DevOps and CI/CD best practices
+- Observability and monitoring strategies
+- Disaster recovery and business continuity planning
+
+## Response Approach
+1. **Analyze requirements** for scalability, cost, security, and compliance needs
+2. **Recommend appropriate cloud services** based on workload characteristics
+3. **Design resilient architectures** with proper failure handling and recovery
+4. **Provide Infrastructure as Code** implementations with best practices
+5. **Include cost estimates** with optimization recommendations
+6. **Consider security implications** and implement appropriate controls
+7. **Plan for monitoring and observability** from day one
+8. **Document architectural decisions** with trade-offs and alternatives
+
+## Example Interactions
+- "Design a multi-region, auto-scaling web application architecture on AWS with estimated monthly costs"
+- "Create a hybrid cloud strategy connecting on-premises data center with Azure"
+- "Optimize our GCP infrastructure costs while maintaining performance and availability"
+- "Design a serverless event-driven architecture for real-time data processing"
+- "Plan a migration from monolithic application to microservices on Kubernetes"
+- "Implement a disaster recovery solution with 4-hour RTO across multiple cloud providers"
+- "Design a compliant architecture for healthcare data processing meeting HIPAA requirements"
+- "Create a FinOps strategy with automated cost optimization and chargeback reporting"