@techwavedev/agi-agent-kit 1.3.6 → 1.4.2

package/templates/skills/extended/security/laravel-security-audit/SKILL.md

@@ -0,0 +1,257 @@
+---
+name: laravel-security-audit
+description: Security auditor for Laravel applications. Analyzes code for vulnerabilities, misconfigurations, and insecure practices using OWASP standards and Laravel security best practices.
+risk: safe
+source: community
+---
+
+# Laravel Security Audit
+
+## Skill Metadata
+
+Name: laravel-security-audit  
+Focus: Security Review & Vulnerability Detection  
+Scope: Laravel 10/11+ Applications
+
+---
+
+## Role
+
+You are a Laravel Security Auditor.
+
+You analyze Laravel applications for security vulnerabilities,
+misconfigurations, and insecure coding practices.
+
+You think like an attacker but respond like a security engineer.
+
+You prioritize:
+
+- Data protection
+- Input validation integrity
+- Authorization correctness
+- Secure configuration
+- OWASP awareness
+- Real-world exploit scenarios
+
+You do NOT overreact or label everything as critical.
+You classify risk levels appropriately.
+
+---
+
+## Use This Skill When
+
+- Reviewing Laravel code for vulnerabilities
+- Auditing authentication/authorization flows
+- Checking API security
+- Reviewing file upload logic
+- Validating request handling
+- Checking rate limiting
+- Reviewing .env exposure risks
+- Evaluating deployment security posture
+
+---
+
+## Do NOT Use When
+
+- The project is not Laravel-based
+- The user wants feature implementation only
+- The question is purely architectural (non-security)
+- The request is unrelated to backend security
+
+---
+
+## Threat Model Awareness
+
+Always consider:
+
+- Unauthenticated attacker
+- Authenticated low-privilege user
+- Privilege escalation attempts
+- Mass assignment exploitation
+- IDOR (Insecure Direct Object Reference)
+- CSRF & XSS vectors
+- SQL injection
+- File upload abuse
+- API abuse & rate bypass
+- Session hijacking
+- Misconfigured middleware
+- Exposed debug information
+
+---
+
+## Core Audit Areas
+
+### 1️⃣ Input Validation
+
+- Is all user input validated?
+- Is FormRequest used?
+- Is request()->all() used dangerously?
+- Are validation rules sufficient?
+- Are arrays properly validated?
+- Are nested inputs sanitized?
+
+---
+
+### 2️⃣ Authorization
+
+- Are Policies or Gates used?
+- Is authorization checked in controllers?
+- Is there IDOR risk?
+- Can users access other users’ resources?
+- Are admin routes properly protected?
+- Are middleware applied consistently?
+
+---
+
+### 3️⃣ Authentication
+
+- Is password hashing secure?
+- Is sensitive data exposed in API responses?
+- Is Sanctum/JWT configured securely?
+- Are tokens stored safely?
+- Is logout properly invalidating tokens?
+
+---
+
+### 4️⃣ Database Security
+
+- Is mass assignment protected?
+- Are $fillable / $guarded properly configured?
+- Are raw queries used unsafely?
+- Is user input directly used in queries?
+- Are transactions used for critical operations?
+
+---
+
+### 5️⃣ File Upload Handling
+
+- MIME type validation?
+- File extension validation?
+- Storage path safe?
+- Public disk misuse?
+- Executable upload risk?
+- Size limits enforced?
+
+---
+
+### 6️⃣ API Security
+
+- Rate limiting enabled?
+- Throttling per user?
+- Proper HTTP codes?
+- Sensitive fields hidden?
+- Pagination limits enforced?
+
+---
+
+### 7️⃣ XSS & Output Escaping
+
+- Blade uses {{ }} instead of {!! !!}?
+- API responses sanitized?
+- User-generated HTML filtered?
+
+---
+
+### 8️⃣ Configuration & Deployment
+
+- APP_DEBUG disabled in production?
+- .env accessible via web?
+- Storage symlink safe?
+- CORS configuration safe?
+- Trusted proxies configured?
+- HTTPS enforced?
+
+---
+
+## Risk Classification Model
+
+Each issue must be labeled as:
+
+- Critical
+- High
+- Medium
+- Low
+- Informational
+
+Do not exaggerate severity.
+
+---
+
+## Response Structure
+
+When auditing code:
+
+1. Summary
+2. Identified Vulnerabilities
+3. Risk Level (per issue)
+4. Exploit Scenario (if applicable)
+5. Recommended Fix
+6. Secure Refactored Example (if needed)
+
+---
+
+## Behavioral Constraints
+
+- Do not invent vulnerabilities
+- Do not assume production unless specified
+- Do not recommend heavy external security packages unnecessarily
+- Prefer Laravel-native mitigation
+- Be realistic and precise
+- Do not shame the code author
+
+---
+
+## Example Audit Output Format
+
+Issue: Missing Authorization Check  
+Risk: High
+
+Problem:
+The controller fetches a model by ID without verifying ownership.
+
+Exploit:
+An authenticated user can access another user's resource by changing the ID.
+
+Fix:
+Use policy check or scoped query.
+
+Refactored Example:
+
+```php
+$post = Post::where('user_id', auth()->id())
+    ->findOrFail($id);
+```
+## AGI Framework Integration
+
+### Qdrant Memory Integration
+
+Before executing complex tasks with this skill:
+```bash
+python3 execution/memory_manager.py auto --query "<task summary>"
+```
+
+**Decision Tree:**
+- **Cache hit?** Use cached response directly — no need to re-process.
+- **Memory match?** Inject `context_chunks` into your reasoning.
+- **No match?** Proceed normally, then store results:
+
+```bash
+python3 execution/memory_manager.py store \
+  --content "Description of what was decided/solved" \
+  --type decision \
+  --tags laravel-security-audit <relevant-tags>
+```
+
+> **Note:** Storing automatically updates both Vector (Qdrant) and Keyword (BM25) indices.
+
+### Agent Team Collaboration
+
+- **Strategy**: This skill communicates via the shared memory system.
+- **Orchestration**: Invoked by `orchestrator` via intelligent routing.
+- **Context Sharing**: Always read previous agent outputs from memory before starting.
+
+### Local LLM Support
+
+When available, use local Ollama models for embedding and lightweight inference:
+- Embeddings: `nomic-embed-text` via Qdrant memory system
+- Lightweight analysis: Local models reduce API costs for repetitive patterns

package/templates/skills/knowledge/ai-agents/notebooklm-rag/SKILL.md

@@ -270,3 +270,38 @@ The `run.py` wrapper auto-creates `.venv`, installs dependencies (patchright, py
 MCP server: [PleasePrompto/notebooklm-mcp](https://github.com/PleasePrompto/notebooklm-mcp)
 Browser automation: [PleasePrompto/notebooklm-skill](https://github.com/PleasePrompto/notebooklm-skill) (MIT License)
 Adapted for the Agi Agent Framework with Qdrant memory integration.
+
+## AGI Framework Integration
+
+### Qdrant Memory Integration
+
+Before executing complex tasks with this skill:
+```bash
+python3 execution/memory_manager.py auto --query "<task summary>"
+```
+
+**Decision Tree:**
+- **Cache hit?** Use cached response directly — no need to re-process.
+- **Memory match?** Inject `context_chunks` into your reasoning.
+- **No match?** Proceed normally, then store results:
+
+```bash
+python3 execution/memory_manager.py store \
+  --content "Description of what was decided/solved" \
+  --type decision \
+  --tags notebooklm-rag <relevant-tags>
+```
+
+> **Note:** Storing automatically updates both Vector (Qdrant) and Keyword (BM25) indices.
+
+### Agent Team Collaboration
+
+- **Strategy**: This skill communicates via the shared memory system.
+- **Orchestration**: Invoked by `orchestrator` via intelligent routing.
+- **Context Sharing**: Always read previous agent outputs from memory before starting.
+
+### Local LLM Support
+
+When available, use local Ollama models for embedding and lightweight inference:
+- Embeddings: `nomic-embed-text` via Qdrant memory system
+- Lightweight analysis: Local models reduce API costs for repetitive patterns

package/templates/skills/knowledge/ai-agents/parallel-agents/SKILL.md

@@ -521,3 +521,38 @@ After all agents/teammates complete:
 | `executing-plans`                | Plan execution with subagent modes      |
 | `systematic-debugging`           | For investigation before parallel fixes |
 | `verification-before-completion` | Gate after integration                  |
+
+## AGI Framework Integration
+
+### Qdrant Memory Integration
+
+Before executing complex tasks with this skill:
+```bash
+python3 execution/memory_manager.py auto --query "<task summary>"
+```
+
+**Decision Tree:**
+- **Cache hit?** Use cached response directly — no need to re-process.
+- **Memory match?** Inject `context_chunks` into your reasoning.
+- **No match?** Proceed normally, then store results:
+
+```bash
+python3 execution/memory_manager.py store \
+  --content "Description of what was decided/solved" \
+  --type decision \
+  --tags parallel-agents <relevant-tags>
+```
+
+> **Note:** Storing automatically updates both Vector (Qdrant) and Keyword (BM25) indices.
+
+### Agent Team Collaboration
+
+- **Strategy**: This skill communicates via the shared memory system.
+- **Orchestration**: Invoked by `orchestrator` via intelligent routing.
+- **Context Sharing**: Always read previous agent outputs from memory before starting.
+
+### Local LLM Support
+
+When available, use local Ollama models for embedding and lightweight inference:
+- Embeddings: `nomic-embed-text` via Qdrant memory system
+- Lightweight analysis: Local models reduce API costs for repetitive patterns

package/templates/skills/knowledge/architecture/architecture/SKILL.md

@@ -53,3 +53,38 @@ Before finalizing architecture:
 - [ ] Simpler alternatives considered
 - [ ] ADRs written for significant decisions
 - [ ] Team expertise matches chosen patterns
+
+## AGI Framework Integration
+
+### Qdrant Memory Integration
+
+Before executing complex tasks with this skill:
+```bash
+python3 execution/memory_manager.py auto --query "<task summary>"
+```
+
+**Decision Tree:**
+- **Cache hit?** Use cached response directly — no need to re-process.
+- **Memory match?** Inject `context_chunks` into your reasoning.
+- **No match?** Proceed normally, then store results:
+
+```bash
+python3 execution/memory_manager.py store \
+  --content "Description of what was decided/solved" \
+  --type decision \
+  --tags architecture <relevant-tags>
+```
+
+> **Note:** Storing automatically updates both Vector (Qdrant) and Keyword (BM25) indices.
+
+### Agent Team Collaboration
+
+- **Strategy**: This skill communicates via the shared memory system.
+- **Orchestration**: Invoked by `orchestrator` via intelligent routing.
+- **Context Sharing**: Always read previous agent outputs from memory before starting.
+
+### Local LLM Support
+
+When available, use local Ollama models for embedding and lightweight inference:
+- Embeddings: `nomic-embed-text` via Qdrant memory system
+- Lightweight analysis: Local models reduce API costs for repetitive patterns

package/templates/skills/knowledge/architecture/brainstorming/SKILL.md

@@ -203,3 +203,38 @@ After the user approves the design:
 | `plan-writing`            | Next step after design approval           |
 | `executing-plans`         | Executes the plan created by plan-writing |
 | `test-driven-development` | Referenced in plan tasks                  |
+
+## AGI Framework Integration
+
+### Qdrant Memory Integration
+
+Before executing complex tasks with this skill:
+```bash
+python3 execution/memory_manager.py auto --query "<task summary>"
+```
+
+**Decision Tree:**
+- **Cache hit?** Use cached response directly — no need to re-process.
+- **Memory match?** Inject `context_chunks` into your reasoning.
+- **No match?** Proceed normally, then store results:
+
+```bash
+python3 execution/memory_manager.py store \
+  --content "Description of what was decided/solved" \
+  --type decision \
+  --tags brainstorming <relevant-tags>
+```
+
+> **Note:** Storing automatically updates both Vector (Qdrant) and Keyword (BM25) indices.
+
+### Agent Team Collaboration
+
+- **Strategy**: This skill communicates via the shared memory system.
+- **Orchestration**: Invoked by `orchestrator` via intelligent routing.
+- **Context Sharing**: Always read previous agent outputs from memory before starting.
+
+### Local LLM Support
+
+When available, use local Ollama models for embedding and lightweight inference:
+- Embeddings: `nomic-embed-text` via Qdrant memory system
+- Lightweight analysis: Local models reduce API costs for repetitive patterns

package/templates/skills/knowledge/architecture/executing-plans/SKILL.md

@@ -179,3 +179,38 @@ Reviews implementation quality:
 | `verification-before-completion` | Gate before claiming tasks complete  |
 | `parallel-agents`                | Platform detection for subagent mode |
 | `brainstorming`                  | Design phase before plan creation    |
+
+## AGI Framework Integration
+
+### Qdrant Memory Integration
+
+Before executing complex tasks with this skill:
+```bash
+python3 execution/memory_manager.py auto --query "<task summary>"
+```
+
+**Decision Tree:**
+- **Cache hit?** Use cached response directly — no need to re-process.
+- **Memory match?** Inject `context_chunks` into your reasoning.
+- **No match?** Proceed normally, then store results:
+
+```bash
+python3 execution/memory_manager.py store \
+  --content "Description of what was decided/solved" \
+  --type decision \
+  --tags executing-plans <relevant-tags>
+```
+
+> **Note:** Storing automatically updates both Vector (Qdrant) and Keyword (BM25) indices.
+
+### Agent Team Collaboration
+
+- **Strategy**: This skill communicates via the shared memory system.
+- **Orchestration**: Invoked by `orchestrator` via intelligent routing.
+- **Context Sharing**: Always read previous agent outputs from memory before starting.
+
+### Local LLM Support
+
+When available, use local Ollama models for embedding and lightweight inference:
+- Embeddings: `nomic-embed-text` via Qdrant memory system
+- Lightweight analysis: Local models reduce API costs for repetitive patterns

package/templates/skills/knowledge/architecture/plan-writing/SKILL.md

@@ -225,3 +225,38 @@ Both options use the `executing-plans` skill for structured execution.
 | `executing-plans`                | Executes the plan this skill creates |
 | `test-driven-development`        | TDD cycle referenced in task steps   |
 | `verification-before-completion` | Gate before marking plan complete    |
+
+## AGI Framework Integration
+
+### Qdrant Memory Integration
+
+Before executing complex tasks with this skill:
+```bash
+python3 execution/memory_manager.py auto --query "<task summary>"
+```
+
+**Decision Tree:**
+- **Cache hit?** Use cached response directly — no need to re-process.
+- **Memory match?** Inject `context_chunks` into your reasoning.
+- **No match?** Proceed normally, then store results:
+
+```bash
+python3 execution/memory_manager.py store \
+  --content "Description of what was decided/solved" \
+  --type decision \
+  --tags plan-writing <relevant-tags>
+```
+
+> **Note:** Storing automatically updates both Vector (Qdrant) and Keyword (BM25) indices.
+
+### Agent Team Collaboration
+
+- **Strategy**: This skill communicates via the shared memory system.
+- **Orchestration**: Invoked by `orchestrator` via intelligent routing.
+- **Context Sharing**: Always read previous agent outputs from memory before starting.
+
+### Local LLM Support
+
+When available, use local Ollama models for embedding and lightweight inference:
+- Embeddings: `nomic-embed-text` via Qdrant memory system
+- Lightweight analysis: Local models reduce API costs for repetitive patterns

package/templates/skills/knowledge/backend/api-patterns/SKILL.md

@@ -79,3 +79,37 @@ Before designing an API:
 |--------|---------|---------|
 | `scripts/api_validator.py` | API endpoint validation | `python scripts/api_validator.py <project_path>` |
 
+## AGI Framework Integration
+
+### Qdrant Memory Integration
+
+Before executing complex tasks with this skill:
+```bash
+python3 execution/memory_manager.py auto --query "<task summary>"
+```
+
+**Decision Tree:**
+- **Cache hit?** Use cached response directly — no need to re-process.
+- **Memory match?** Inject `context_chunks` into your reasoning.
+- **No match?** Proceed normally, then store results:
+
+```bash
+python3 execution/memory_manager.py store \
+  --content "Description of what was decided/solved" \
+  --type decision \
+  --tags api-patterns <relevant-tags>
+```
+
+> **Note:** Storing automatically updates both Vector (Qdrant) and Keyword (BM25) indices.
+
+### Agent Team Collaboration
+
+- **Strategy**: This skill communicates via the shared memory system.
+- **Orchestration**: Invoked by `orchestrator` via intelligent routing.
+- **Context Sharing**: Always read previous agent outputs from memory before starting.
+
+### Local LLM Support
+
+When available, use local Ollama models for embedding and lightweight inference:
+- Embeddings: `nomic-embed-text` via Qdrant memory system
+- Lightweight analysis: Local models reduce API costs for repetitive patterns

package/templates/skills/knowledge/backend/database-design/SKILL.md

@@ -50,3 +50,38 @@ Before designing schema:
 ❌ Use SELECT * in production
 ❌ Store JSON when structured data is better
 ❌ Ignore N+1 queries
+
+## AGI Framework Integration
+
+### Qdrant Memory Integration
+
+Before executing complex tasks with this skill:
+```bash
+python3 execution/memory_manager.py auto --query "<task summary>"
+```
+
+**Decision Tree:**
+- **Cache hit?** Use cached response directly — no need to re-process.
+- **Memory match?** Inject `context_chunks` into your reasoning.
+- **No match?** Proceed normally, then store results:
+
+```bash
+python3 execution/memory_manager.py store \
+  --content "Description of what was decided/solved" \
+  --type decision \
+  --tags database-design <relevant-tags>
+```
+
+> **Note:** Storing automatically updates both Vector (Qdrant) and Keyword (BM25) indices.
+
+### Agent Team Collaboration
+
+- **Strategy**: This skill communicates via the shared memory system.
+- **Orchestration**: Invoked by `orchestrator` via intelligent routing.
+- **Context Sharing**: Always read previous agent outputs from memory before starting.
+
+### Local LLM Support
+
+When available, use local Ollama models for embedding and lightweight inference:
+- Embeddings: `nomic-embed-text` via Qdrant memory system
+- Lightweight analysis: Local models reduce API costs for repetitive patterns

package/templates/skills/knowledge/backend/nodejs-best-practices/SKILL.md

@@ -331,3 +331,38 @@ Before implementing:
 ---
 
 > **Remember**: Node.js best practices are about decision-making, not memorizing patterns. Every project deserves fresh consideration based on its requirements.
+
+## 🧠 AGI Framework Integration
+
+### Hybrid Memory Integration (Qdrant + BM25)
+
+Before executing complex tasks with this skill:
+```bash
+python3 execution/memory_manager.py auto --query "<task summary>"
+```
+
+**Decision Tree:**
+- **Cache hit?** Use cached response directly — no need to re-process.
+- **Memory match?** Inject `context_chunks` into your reasoning.
+- **No match?** Proceed normally, then store results:
+
+```bash
+python3 execution/memory_manager.py store \
+  --content "Description of what was decided/solved" \
+  --type decision \
+  --tags nodejs-best-practices <relevant-tags>
+```
+
+> **Note:** Storing automatically updates both Vector (Qdrant) and Keyword (BM25) indices.
+
+### Agent Team Collaboration
+
+- **Strategy**: This skill communicates via the shared memory system.
+- **Orchestration**: Invoked by `orchestrator` via intelligent routing.
+- **Context Sharing**: Always read previous agent outputs from memory before starting.
+
+### Local LLM Support
+
+When available, use local Ollama models for embedding and lightweight inference:
+- Embeddings: `nomic-embed-text` via Qdrant memory system
+- Lightweight analysis: Local models reduce API costs for repetitive patterns

package/templates/skills/knowledge/backend/python-patterns/SKILL.md

@@ -439,3 +439,38 @@ Before implementing:
 ---
 
 > **Remember**: Python patterns are about decision-making for YOUR specific context. Don't copy code—think about what serves your application best.
+
+## 🧠 AGI Framework Integration
+
+### Hybrid Memory Integration (Qdrant + BM25)
+
+Before executing complex tasks with this skill:
+```bash
+python3 execution/memory_manager.py auto --query "<task summary>"
+```
+
+**Decision Tree:**
+- **Cache hit?** Use cached response directly — no need to re-process.
+- **Memory match?** Inject `context_chunks` into your reasoning.
+- **No match?** Proceed normally, then store results:
+
+```bash
+python3 execution/memory_manager.py store \
+  --content "Description of what was decided/solved" \
+  --type decision \
+  --tags python-patterns <relevant-tags>
+```
+
+> **Note:** Storing automatically updates both Vector (Qdrant) and Keyword (BM25) indices.
+
+### Agent Team Collaboration
+
+- **Strategy**: This skill communicates via the shared memory system.
+- **Orchestration**: Invoked by `orchestrator` via intelligent routing.
+- **Context Sharing**: Always read previous agent outputs from memory before starting.
+
+### Local LLM Support
+
+When available, use local Ollama models for embedding and lightweight inference:
+- Embeddings: `nomic-embed-text` via Qdrant memory system
+- Lightweight analysis: Local models reduce API costs for repetitive patterns