refactor: streamline agents and remove everything MCP tool

- Update MCP server name from flow_memory to sylphx_flow
- Remove everything MCP tool from all configurations and documentation
- Simplify agent tools configuration (remove redundant memory tool listings)
- Clean up agent documentation to focus on workflows, not tool tutorials
- Remove Sylphx Flow self-references from agent docs
- Update all CLI commands and help text to reflect changes
- Maintain core coordination patterns while simplifying configuration

Author: shtse8

README.md

@@ -83,7 +83,7 @@ Users can manage the same database via CLI:
 | Tool | Purpose | API Key Required |
 |------|---------|------------------|
 | `memory` | Agent coordination & memory | ❌ |
-| `everything` | Filesystem, web, git tools | ❌ |
+
 | `gpt-image-1-mcp` | GPT image generation | ✅ |
 | `perplexity-ask` | Perplexity search | ✅ |
 | `gemini-google-search` | Google search via Gemini | ✅ |

agent-updates-summary.md

@@ -0,0 +1,80 @@
+# Sylphx Flow Agent Updates Summary
+
+## Overview
+Updated all core agent files in `/agents/core/` to use the correct Sylphx Flow memory tools and patterns.
+
+## Files Updated
+- ✅ `planner.md` - Strategic Planning Agent
+- ✅ `researcher.md` - Research and Analysis Agent  
+- ✅ `reviewer.md` - Code Review Agent
+- ✅ `tester.md` - Testing and Quality Assurance Agent
+- ✅ `coder.md` - Code Implementation Agent
+
+## Key Changes Made
+
+### 1. Tool Configuration
+Added correct memory tools to each agent's frontmatter:
+```yaml
+tools:
+  memory_set: true
+  memory_get: true
+  memory_search: true
+  memory_list: true
+  memory_delete: true
+  memory_clear: true
+  memory_stats: true
+```
+
+### 2. Memory Coordination Sections
+Added comprehensive "Memory Coordination (Sylphx Flow)" sections to each agent with:
+- Memory management patterns
+- Agent coordination workflows
+- TypeScript code examples
+- Namespace organization strategies
+
+### 3. Tool Integration Updates
+Updated "Tool Integration" sections to include:
+- Memory-first coordination patterns
+- Sylphx Flow architecture integration
+- Proper error handling patterns
+- UUID v7 usage for identifiers
+
+### 4. Fixed Tool Names
+Replaced incorrect tool names:
+- ❌ `flow_memory_memory_set` → ✅ `memory_set`
+- ❌ `flow_memory_memory_get` → ✅ `memory_get`
+- ❌ `flow_memory_memory_search` → ✅ `memory_search`
+
+### 5. Sylphx Flow Patterns
+Integrated project-specific patterns:
+- Functional programming principles
+- TypeScript strict typing
+- Domain-driven architecture
+- Vitest testing framework
+- Biome linting standards
+- UUID v7 for identifiers
+
+## Memory Namespace Organization
+Each agent uses dedicated namespaces:
+- `planner`: Plans and task breakdowns
+- `researcher`: Findings and analysis
+- `coder`: Implementation status and decisions
+- `reviewer`: Review results and quality metrics
+- `tester`: Test results and coverage data
+
+## Coordination Workflows
+Established clear coordination patterns:
+1. **Research Phase**: Researcher stores findings
+2. **Planning Phase**: Planner retrieves research and creates plans
+3. **Implementation Phase**: Coder coordinates with planner/researcher
+4. **Review Phase**: Reviewer analyzes implementation
+5. **Testing Phase**: Tester validates quality
+
+## Benefits
+- ✅ Real-time agent coordination through shared memory
+- ✅ Persistent state management across sessions
+- ✅ Proper error handling and TypeScript patterns
+- ✅ Consistent with Sylphx Flow architecture
+- ✅ Follows project coding standards and guidelines
+
+All agents are now properly integrated with the Sylphx Flow MCP server and can coordinate effectively through the memory system.

agents/core/coder.md

@@ -90,8 +90,16 @@ const heavyModule = () => import('./heavy-module');
 ### 3. Test-Driven Development
 
 ```javascript
-// Write test first
+// Write test first using Vitest
+import { describe, it, expect, beforeEach } from 'vitest';
+
 describe('UserService', () => {
+  let service: UserService;
+  
+  beforeEach(() => {
+    service = new UserService(mockDatabase);
+  });
+
   it('should calculate discount correctly', () => {
     const user = createMockUser({ purchases: 10 });
     const discount = service.calculateDiscount(user);
@@ -189,37 +197,78 @@ src/
  */
 ```
 
-## Tool Integration (OpenCode)
+### Project Standards
 
-### File Operations
-- Use `Read` tool to examine existing code structure
-- Use `Edit` tool for precise code modifications
-- Use `Write` tool for creating new files
-- Use `Glob` and `Grep` for code discovery and analysis
+```javascript
+// Follow functional programming patterns
+export const createUserService = (database: Database): UserService => ({
+  calculateDiscount: (user: User): number => {
+    // Pure function implementation
+  },
+  
+  createUser: async (userData: CreateUserDto): Promise<User> => {
+    // Error handling with custom error types
+    try {
+      const validatedUser = UserSchema.parse(userData);
+      return await database.users.create(validatedUser);
+    } catch (error) {
+      throw new ValidationError('Invalid user data', error);
+    }
+  }
+});
 
-### Command Execution
-- Use `Bash` tool for running tests, linting, and build processes
-- Execute package managers (npm, yarn, pnpm) for dependency management
-- Run development servers and build scripts
-- Perform code quality checks and formatting
+// Use UUID v7 for IDs
+import { v7 as uuidv7 } from 'uuid';
 
-### Search & Discovery
-- Use `Grep` to find code patterns and dependencies
-- Use `Glob` to locate files by naming conventions
-- Search for existing implementations to maintain consistency
+const createUserEntity = (userData: CreateUserDto): User => ({
+  id: uuidv7(),
+  ...userData,
+  createdAt: new Date().toISOString(),
+  updatedAt: new Date().toISOString()
+});
+```
 
-### Performance Monitoring
-- Run performance tests via command line
-- Use profiling tools available in the project
-- Monitor bundle sizes and load times
-- Analyze runtime performance with built-in tools
+## Agent Coordination
+
+### Memory-Based Collaboration
+```typescript
+// Report implementation status
+memory_set({
+  key: 'implementation-status',
+  value: JSON.stringify({
+    agent: 'coder',
+    status: 'implementing|testing|completed|blocked',
+    feature: 'user authentication',
+    files: ['auth.service.ts', 'auth.controller.ts'],
+    timestamp: Date.now(),
+    progress: 65
+  }),
+  namespace: 'coder'
+})
+
+// Get research findings from researcher
+memory_get({
+  key: 'findings',
+  namespace: 'researcher'
+})
+
+// Get requirements from planner
+memory_get({
+  key: 'current-plan',
+  namespace: 'planner'
+})
+```
 
-## Collaboration
+### Workflow Integration
+- **Planning Phase**: Retrieve requirements and research findings from memory
+- **Implementation Phase**: Store progress and decisions for coordination
+- **Testing Phase**: Coordinate with tester for validation requirements
+- **Review Phase**: Share implementation results with reviewer
 
-- Coordinate with team members through clear documentation
-- Follow established project patterns and conventions
-- Provide comprehensive commit messages
-- Document technical decisions in code comments
-- Share knowledge through README files and documentation
+### Quality Standards
+- Run biome linting and formatting before completion
+- Execute test suite and ensure coverage
+- Perform TypeScript type checking
+- Follow functional programming patterns from project guidelines
 
-Remember: Good code is written for humans to read, and only incidentally for machines to execute. Focus on clarity, maintainability, and correctness. Use OpenCode tools effectively to analyze, modify, and test code.
+Remember: Coordinate through memory for seamless workflow integration. Focus on clean, maintainable code that meets requirements.

agents/core/planner.md

@@ -77,12 +77,26 @@ plan:
     - "Measurable outcome 2"
 ```
 
+## Agent Coordination
+
+### Agent Communication
+- Store plans and status updates for other agents
+- Retrieve research findings from researcher agent
+- Use `memory_search` to find related plans and dependencies
+- Store plans under namespace `planner` for organization
+
+### Coordination Workflow
+1. **Research Phase**: Retrieve findings from researcher via memory
+2. **Planning Phase**: Create and store plans using memory
+3. **Validation Phase**: Search for conflicts with memory search
+4. **Execution Phase**: Update status for other agents via memory
+
 ## Collaboration Guidelines
 
 - Coordinate with other agents to validate feasibility
 - Update plans based on execution feedback
-- Maintain clear communication channels
-- Document all planning decisions
+- Maintain clear communication channels through memory
+- Document all planning decisions in persistent storage
 
 ## Best Practices
 
@@ -104,21 +118,24 @@ plan:
    - Efficient resource utilization
    - Continuous progress visibility
 
-## Tool Integration (OpenCode)
+## Agent Coordination
 
-### Task Management
-- Use `Write` tool to create plan files and task breakdowns
-- Use `Read` tool to analyze existing project structure and requirements
-- Use `Grep` to find related tasks and dependencies
-- Use `Bash` to run project analysis tools and gather metrics
+### Memory Communication
+- Use memory namespaces for agent coordination:
+  - `planner`: Plans and task breakdowns
+  - `researcher`: Findings and analysis
+  - `coder`: Implementation status
+  - `reviewer`: Review results
+  - `tester`: Test results
 
-### Documentation
+### Documentation Strategy
+- Store plans in memory for agent coordination
 - Create markdown files for detailed plans
 - Generate task lists in TODO format
 - Document dependencies and timelines
 - Track progress with status files
 
-### Communication
+### Communication Patterns
 - Write clear documentation for other agents
 - Create handoff instructions between tasks
 - Document assumptions and constraints
@@ -127,51 +144,15 @@ plan:
 ## Planning Templates
 
 ### Simple Task Breakdown
-```markdown
-## Task: [Task Name]
-
-### Objective
-[Clear goal description]
-
-### Subtasks
-1. [ ] [Subtask 1] - [Agent] - [Time]
-2. [ ] [Subtask 2] - [Agent] - [Time]
-3. [ ] [Subtask 3] - [Agent] - [Time]
-
-### Dependencies
-- [Dependency 1]
-- [Dependency 2]
-
-### Success Criteria
-- [ ] [Criterion 1]
-- [ ] [Criterion 2]
-```
+- Objective: Clear goal description
+- Subtasks: Actionable items with agent assignments and time estimates
+- Dependencies: Required prerequisites
+- Success Criteria: Measurable outcomes
 
 ### Complex Project Plan
-```markdown
-# Project: [Project Name]
-
-## Overview
-[Brief description and goals]
-
-## Phase 1: [Phase Name]
-**Timeline:** [Duration]
-**Priority:** [High/Medium/Low]
-
-### Tasks
-- **T1:** [Task description] ([Agent], [Time])
-- **T2:** [Task description] ([Agent], [Time])
-- **T3:** [Task description] ([Agent], [Time])
-
-### Dependencies
-- T2 depends on T1
-- T3 depends on T2
-
-## Critical Path
-[T1] → [T2] → [T3]
-
-## Risks & Mitigations
-- **Risk:** [Description] → **Mitigation:** [Strategy]
-```
+- Overview: Brief description and goals
+- Phases: Organized task groups with timelines and priorities
+- Critical Path: Sequence of dependent tasks
+- Risks & Mitigations: Potential issues and strategies
 
-Remember: A good plan executed now is better than a perfect plan executed never. Focus on creating actionable, practical plans that drive progress. Use OpenCode tools to analyze, document, and coordinate planning activities.
+Remember: Focus on creating actionable, practical plans that drive progress. Coordinate through memory for seamless workflow integration.