AGENTS.md

1# Claude Flow V3 - Agent Guide
2 
3> **For OpenAI Codex CLI** - Agentic AI Foundation standard
4> Skills: `$skill-name` | Config: `.agents/config.toml`
5 
6---
7 
8## 📢 TL;DR - READ THIS FIRST
9 
10```
11╔═══════════════════════════════════════════════════════════════════════════╗
12║  1. claude-flow = LEDGER (tracks state, stores memory, coordinates)       ║
13║  2. Codex = EXECUTOR (writes code, runs commands, creates files)          ║
14║  3. NEVER stop after calling claude-flow - IMMEDIATELY continue working   ║
15║  4. If you need something BUILT/EXECUTED, YOU do it, not claude-flow      ║
16║  5. ALWAYS search memory BEFORE starting: memory search --query "task"    ║
17║  6. ALWAYS store patterns AFTER success: memory store --namespace patterns║
18╚═══════════════════════════════════════════════════════════════════════════╝
19```
20 
21**Workflow (Use MCP Tools):**
221. `memory_search(query="task keywords")` → LEARN from past patterns (score > 0.7 = use it)
232. `swarm_init(topology="hierarchical")` → coordination record (instant)
243. **YOU write the code / run the commands** ← THIS IS WHERE WORK HAPPENS
254. `memory_store(key="pattern-x", value="what worked", namespace="patterns")` → REMEMBER for next time
26 
27---
28 
29## Ruflo Policy-Governed Concurrent Codex Workflow
30 
31Ruflo is the coordination ledger and policy decision point. Codex agents are
32the executors. Coordination records do not write code or run tests.
33 
34Use `guidance_brain({ mode: "recommend", task: "..." })` to select Ruflo
35capabilities from the live MCP registry. A registered tool is not necessarily
36configured, reachable, healthy, or authorized. If it is unavailable, continue
37with compatible guidance tools, CLI discovery, and repository instructions.
38 
391. Recall relevant AgentDB memory and ADRs.
402. Inspect source, runtime, dependencies, policy, and health.
413. Route to the smallest capable topology, agents, skills, and tools.
424. Plan acceptance criteria, safety envelope, ownership, and validation.
435. Execute with Codex workers in isolated scopes; Ruflo records coordination.
446. Test focused, regression, and failure paths.
457. Validate types, security, policy, compatibility, and artifact integrity.
468. Benchmark a source-bound candidate against a source-bound baseline.
479. Optimize only measured bottlenecks without weakening safety.
4810. Bind claims and evidence into exact source/build receipts.
4911. Reconcile handoffs and disclose unresolved limitations.
5012. Publish only through a separately authorized release gate.
51 
52Hard invariants:
53 
54- Never run two writers in one worktree.
55- Delegation may only reduce tools, servers, namespaces, network, spend,
56  concurrency, expiry, and depth.
57- Policy denial cancels dependent work before side effects.
58- MetaHarness may evaluate candidates concurrently, but only ADR-322A may
59  promote them and MetaHarness may never expand its own SafetyEnvelope.
60- Do not commit, push, merge, release, or remove worktrees unless authorized.
61- Existing installations migrate in `legacy` policy mode; use `observe` before
62  switching to `enforce`.
63 
64Repository harness integration:
65 
66- If tracked repository instructions define a collaboration harness, start its
67  session only after assigning an isolated worktree.
68- Inspect existing claims, acquire exact paths/resources/ports, renew leases,
69  check acknowledged inbox messages at integration boundaries, and release ownership on
70  handoff or exit.
71- A repository lease coordinates ownership; it does not grant authorization.
72  Protected work still requires the ADR-324/325 action capability and current
73  fencing epoch.
74- In-memory reference adapters demonstrate semantics; they are not distributed,
75  restart-durable release authorities.
76- Heartbeats and lease expiry establish liveness; a PID is diagnostic only.
77- `HEAD` alone is not an exact source-state identity in a dirty worktree.
78  Release evidence must bind a clean commit or an immutable snapshot of tracked
79  and untracked changes.
80 
81Useful checks:
82 
83```bash
84npx ruflo policy status
85npx ruflo policy verify
86npx ruflo metaharness flywheel status
87```
88 
89Repository release contract:
90 
91- The stable public train is exactly `@claude-flow/cli`, `claude-flow`, and
92  `ruflo`; internal `@claude-flow/*` components are bundled and are not part of
93  a normal standalone publish.
94- Publish from a clean, reviewed source state in that order.
95- Only the CLI publish receives the helper-signing configuration from
96  `ruv-dev`; use the existing authenticated npm session for publication.
97- Run `node scripts/audit-umbrella-version-lockstep.mjs`, verify all three
98  registry versions, and align `latest`, `alpha`, and `v3alpha`.
99 
100---
101 
102## 🚨 CRITICAL: CODEX DOES THE WORK, CLAUDE-FLOW ORCHESTRATES
103 
104```
105┌─────────────────────────────────────────────────────────────┐
106│  CLAUDE-FLOW = ORCHESTRATOR (tracks state, coordinates)     │
107│  CODEX = WORKER (writes code, runs commands, implements)    │
108└─────────────────────────────────────────────────────────────┘
109```
110 
111### ❌ WRONG: Expecting claude-flow to execute tasks
112```bash
113npx claude-flow swarm start --objective "Build API"
114# WRONG: Waiting for claude-flow to build the API
115# Claude-flow does NOT execute code!
116```
117 
118### ✅ CORRECT: Codex executes, claude-flow tracks
119```bash
120# 1. Tell claude-flow what you're doing (optional coordination)
121npx claude-flow swarm init --topology hierarchical --max-agents 1
122npx claude-flow agent spawn --type coder --name codex-worker
123 
124# 2. YOU (CODEX) DO THE ACTUAL WORK:
125mkdir -p src
126cat > src/api.ts << 'EOF'
127export function hello() { return "Hello World"; }
128EOF
129 
130# 3. Report to claude-flow what you did (optional)
131npx claude-flow memory store --key "api-created" --value "src/api.ts" --namespace results
132```
133 
134### The Division of Labor
135 
136| Component | Role | Examples |
137|-----------|------|----------|
138| **CODEX** | EXECUTES | Write files, run tests, create code, shell commands |
139| **claude-flow** | ORCHESTRATES | Track agents, store memory, coordinate tasks |
140 
141---
142 
143## ⛔ DON'T STOP AFTER CALLING CLAUDE-FLOW
144 
145```
146┌─────────────────────────────────────────────────────────────────────────┐
147│  ❌ WRONG: Call claude-flow → STOP → Wait for results                   │
148│  ✅ RIGHT: Call claude-flow → IMMEDIATELY continue → YOU do the work    │
149└─────────────────────────────────────────────────────────────────────────┘
150```
151 
152### ❌ WRONG Pattern (Stopping)
153```bash
154npx claude-flow swarm init --topology hierarchical
155npx claude-flow agent spawn --type coder --name worker-1
156npx claude-flow swarm start --objective "Build hello world"
157# WRONG: Codex stops here and waits for something to happen
158# Nothing will happen! Claude-flow doesn't execute code!
159```
160 
161### ✅ CORRECT Pattern (Continue Immediately)
162```bash
163# Step 1: Coordination (optional)
164npx claude-flow swarm init --topology hierarchical
165npx claude-flow agent spawn --type coder --name worker-1
166 
167# Step 2: IMMEDIATELY DO THE WORK YOURSELF - DON'T WAIT!
168echo 'console.log("Hello World!");' > hello.js
169node hello.js
170 
171# Step 3: Report what you did
172npx claude-flow memory store --key "result" --value "Hello World printed" --namespace results
173```
174 
175### The Rule
176**After ANY claude-flow command, IMMEDIATELY continue with your own work.**
177 
178Claude-flow commands return instantly. They create coordination RECORDS only.
179You must ALWAYS follow up with YOUR OWN execution.
180 
181| After This... | IMMEDIATELY Do This... |
182|---------------|----------------------|
183| `swarm init` | Start writing code |
184| `agent spawn` | Continue implementation |
185| `task create` | Execute the task yourself |
186| `swarm start` | Begin actual work |
187 
188---
189 
190### When to Use Claude-Flow Commands
191 
192| Use Case | Claude-Flow Command | Then Codex Does |
193|----------|---------------------|-----------------|
194| Track progress | `memory store --key "step1" --value "done"` | Continue to next step |
195| Multi-step tasks | `task create --description "step 2"` | Execute step 2 |
196| Store results | `memory store --key "output" --value "..."` | Move on |
197| Coordinate | `swarm init` | Start working |
198 
199### Hello World - Correct Pattern
200 
201```bash
202# STEP 1: Optional - register with orchestrator
203npx claude-flow swarm init --topology mesh --max-agents 1
204 
205# STEP 2: CODEX DOES THE WORK
206echo 'console.log("Hello World!");' > hello.js
207node hello.js
208 
209# STEP 3: Optional - report completion
210npx claude-flow memory store --key "hello-result" --value "printed Hello World" --namespace results
211```
212 
213**REMEMBER: If you need something DONE, YOU do it. Claude-flow just tracks.**
214 
215---
216 
217## ⚡ QUICK COMMANDS (NO DISCOVERY NEEDED)
218 
219### Spawn N-Agent Swarm (Copy-Paste Ready)
220 
221```bash
222# 5-AGENT SWARM - Run these commands in sequence:
223npx claude-flow swarm init --topology hierarchical --max-agents 8
224npx claude-flow agent spawn --type coordinator --name coord-1
225npx claude-flow agent spawn --type coder --name coder-1
226npx claude-flow agent spawn --type coder --name coder-2
227npx claude-flow agent spawn --type tester --name tester-1
228npx claude-flow agent spawn --type reviewer --name reviewer-1
229npx claude-flow swarm start --objective "Your task here" --strategy development
230```
231 
232### Common Swarm Patterns
233 
234| Task | Exact Command |
235|------|---------------|
236| Init hierarchical swarm | `npx claude-flow swarm init --topology hierarchical --max-agents 8` |
237| Init mesh swarm | `npx claude-flow swarm init --topology mesh --max-agents 5` |
238| Init V3 mode (15 agents) | `npx claude-flow swarm init --v3-mode` |
239| Spawn coder | `npx claude-flow agent spawn --type coder --name coder-1` |
240| Spawn tester | `npx claude-flow agent spawn --type tester --name tester-1` |
241| Spawn coordinator | `npx claude-flow agent spawn --type coordinator --name coord-1` |
242| Spawn architect | `npx claude-flow agent spawn --type architect --name arch-1` |
243| Spawn reviewer | `npx claude-flow agent spawn --type reviewer --name rev-1` |
244| Spawn researcher | `npx claude-flow agent spawn --type researcher --name res-1` |
245| Start swarm | `npx claude-flow swarm start --objective "task" --strategy development` |
246| Check swarm status | `npx claude-flow swarm status` |
247| List agents | `npx claude-flow agent list` |
248| Stop swarm | `npx claude-flow swarm stop` |
249 
250### Agent Types (Use with `--type`)
251 
252| Type | Purpose |
253|------|---------|
254| `coordinator` | Orchestrates other agents |
255| `coder` | Writes code |
256| `tester` | Writes tests |
257| `reviewer` | Reviews code |
258| `architect` | Designs systems |
259| `researcher` | Analyzes requirements |
260| `security-architect` | Security design |
261| `performance-engineer` | Optimization |
262 
263### Task Commands
264 
265| Action | Command |
266|--------|---------|
267| Create task | `npx claude-flow task create --type implementation --description "desc"` |
268| List tasks | `npx claude-flow task list` |
269| Assign task | `npx claude-flow task assign TASK_ID --agent AGENT_NAME` |
270| Task status | `npx claude-flow task status TASK_ID` |
271| Cancel task | `npx claude-flow task cancel TASK_ID` |
272 
273### Memory Commands
274 
275| Action | Command |
276|--------|---------|
277| Store | `npx claude-flow memory store --key "key" --value "value" --namespace patterns` |
278| Search | `npx claude-flow memory search --query "search terms"` |
279| List | `npx claude-flow memory list --namespace patterns` |
280| Retrieve | `npx claude-flow memory retrieve --key "key"` |
281 
282---
283 
284## 🚀 SWARM RECIPES
285 
286### Recipe 1: Hello World Test (COMPLETE EXAMPLE)
287 
288**Step 1: Setup coordination** (returns instantly - don't stop!)
289```bash
290npx claude-flow swarm init --topology mesh --max-agents 5
291npx claude-flow agent spawn --type coder --name hello-main
292# ⚠️ DON'T STOP HERE - CONTINUE IMMEDIATELY TO STEP 2
293```
294 
295**Step 2: YOU (Codex) execute the task** (THIS IS THE REAL WORK)
296```bash
297# ✅ YOU create the file
298echo 'console.log("Hello World from Swarm!");' > /tmp/hello-swarm.js
299 
300# ✅ YOU execute it
301node /tmp/hello-swarm.js
302# Output: Hello World from Swarm!
303```
304 
305**Step 3: Report completion** (optional - store results)
306```bash
307npx claude-flow memory store --key "hello-world-result" --value "Executed: Hello World from Swarm!" --namespace results
308```
309 
310### Recipe 1b: 5-Agent Concurrent Hello World (COMPLETE)
311```bash
312# COORDINATION (instant - creates records only)
313npx claude-flow swarm init --topology hierarchical --max-agents 5
314for i in 1 2 3 4 5; do
315  npx claude-flow agent spawn --type coder --name "worker-$i"
316done
317 
318# ⚠️ NOW YOU DO THE ACTUAL CONCURRENT WORK:
319for i in 1 2 3 4 5; do
320  (echo "Worker $i: Hello World!" && sleep 0.$i) &
321done
322wait
323echo "All 5 workers completed!"
324 
325# REPORT (optional)
326npx claude-flow memory store --key "concurrent-result" --value "5 workers completed" --namespace results
327```
328 
329### Recipe 1b: Hello World (Single Command Block)
330```bash
331# All-in-one execution
332npx claude-flow swarm init --topology mesh --max-agents 5 && \
333npx claude-flow agent spawn --type coder --name hello-main && \
334npx claude-flow swarm start --objective "Print hello world" --strategy development && \
335echo 'console.log("Hello World from Swarm!");' > /tmp/hello-swarm.js && \
336node /tmp/hello-swarm.js && \
337npx claude-flow memory store --key "hello-world-result" --value "Success" --namespace results
338```
339 
340### Recipe 2: Feature Implementation (6 Agents)
341```bash
342npx claude-flow swarm init --topology hierarchical --max-agents 8
343npx claude-flow agent spawn --type coordinator --name lead
344npx claude-flow agent spawn --type architect --name arch
345npx claude-flow agent spawn --type coder --name impl-1
346npx claude-flow agent spawn --type coder --name impl-2
347npx claude-flow agent spawn --type tester --name test
348npx claude-flow agent spawn --type reviewer --name review
349npx claude-flow swarm start --objective "Implement [feature]" --strategy development
350```
351 
352### Recipe 3: Bug Fix (4 Agents)
353```bash
354npx claude-flow swarm init --topology hierarchical --max-agents 4
355npx claude-flow agent spawn --type coordinator --name lead
356npx claude-flow agent spawn --type researcher --name debug
357npx claude-flow agent spawn --type coder --name fix
358npx claude-flow agent spawn --type tester --name verify
359npx claude-flow swarm start --objective "Fix [bug]" --strategy development
360```
361 
362### Recipe 4: Security Audit (3 Agents)
363```bash
364npx claude-flow swarm init --topology hierarchical --max-agents 4
365npx claude-flow agent spawn --type coordinator --name lead
366npx claude-flow agent spawn --type security-architect --name audit
367npx claude-flow agent spawn --type reviewer --name review
368npx claude-flow swarm start --objective "Security audit" --strategy development
369```
370 
371### Recipe 5: V3 Full Coordination (15 Agents)
372```bash
373npx claude-flow swarm init --v3-mode
374npx claude-flow swarm coordinate --agents 15
375```
376 
377---
378 
379## 📋 BEHAVIORAL RULES
380 
381- **YOU (CODEX) execute tasks** - claude-flow only orchestrates
382- Do what is asked; nothing more, nothing less
383- NEVER create files unless absolutely necessary
384- ALWAYS prefer editing existing files
385- NEVER save to root folder
386- NEVER commit secrets or .env files
387- ALWAYS read a file before editing it
388- NEVER wait for claude-flow to "do work" - it doesn't execute, YOU do
389- Use claude-flow commands to TRACK progress, not to EXECUTE tasks
390 
391## 📁 FILE ORGANIZATION
392 
393| Directory | Purpose |
394|-----------|---------|
395| `/src` | Source code |
396| `/tests` | Test files |
397| `/docs` | Documentation |
398| `/config` | Configuration |
399| `/scripts` | Utility scripts |
400 
401## 🎯 WHEN TO USE SWARMS
402 
403**USE SWARM:**
404- Multiple files (3+)
405- New feature implementation
406- Cross-module refactoring
407- API changes with tests
408- Security-related changes
409- Performance optimization
410 
411**SKIP SWARM:**
412- Single file edits
413- Simple bug fixes (1-2 lines)
414- Documentation updates
415- Configuration changes
416 
417---
418 
419## 🔧 CLI REFERENCE
420 
421### Swarm Commands
422```bash
423npx claude-flow swarm init [--topology TYPE] [--max-agents N] [--v3-mode]
424npx claude-flow swarm start --objective "task" --strategy [development|research]
425npx claude-flow swarm status [SWARM_ID]
426npx claude-flow swarm stop [SWARM_ID]
427npx claude-flow swarm scale --count N
428npx claude-flow swarm coordinate --agents N
429```
430 
431### Agent Commands
432```bash
433npx claude-flow agent spawn --type TYPE --name NAME
434npx claude-flow agent list [--filter active|idle|busy]
435npx claude-flow agent status AGENT_ID
436npx claude-flow agent stop AGENT_ID
437npx claude-flow agent metrics [AGENT_ID]
438npx claude-flow agent health
439npx claude-flow agent logs AGENT_ID
440```
441 
442### Task Commands
443```bash
444npx claude-flow task create --type TYPE --description "desc"
445npx claude-flow task list [--all]
446npx claude-flow task status TASK_ID
447npx claude-flow task assign TASK_ID --agent AGENT_NAME
448npx claude-flow task cancel TASK_ID
449npx claude-flow task retry TASK_ID
450```
451 
452### Memory Commands
453```bash
454npx claude-flow memory store --key KEY --value VALUE [--namespace NS]
455npx claude-flow memory search --query "terms" [--namespace NS]
456npx claude-flow memory list [--namespace NS]
457npx claude-flow memory retrieve --key KEY [--namespace NS]
458npx claude-flow memory init [--force]
459```
460 
461### Hooks Commands
462```bash
463npx claude-flow hooks pre-task --description "task"
464npx claude-flow hooks post-task --task-id ID --success true
465npx claude-flow hooks route --task "task"
466npx claude-flow hooks session-start --session-id ID
467npx claude-flow hooks session-end --export-metrics true
468npx claude-flow hooks worker list
469npx claude-flow hooks worker dispatch --trigger audit
470```
471 
472### System Commands
473```bash
474npx claude-flow init [--wizard] [--codex] [--full]
475npx claude-flow daemon start
476npx claude-flow daemon stop
477npx claude-flow daemon status
478npx claude-flow doctor [--fix]
479npx claude-flow status
480npx claude-flow mcp start
481```
482 
483---
484 
485## 🔌 TOPOLOGIES
486 
487| Topology | Use Case | Command Flag |
488|----------|----------|--------------|
489| `hierarchical` | Coordinated teams, anti-drift | `--topology hierarchical` |
490| `mesh` | Peer-to-peer, equal agents | `--topology mesh` |
491| `hierarchical-mesh` | Hybrid (recommended for V3) | `--topology hierarchical-mesh` |
492| `ring` | Sequential processing | `--topology ring` |
493| `star` | Central coordinator | `--topology star` |
494| `adaptive` | Dynamic switching | `--topology adaptive` |
495 
496## 🤖 AGENT TYPES
497 
498### Core
499`coordinator`, `coder`, `tester`, `reviewer`, `architect`, `researcher`
500 
501### Specialized
502`security-architect`, `security-auditor`, `memory-specialist`, `performance-engineer`
503 
504### Swarm Coordination
505`hierarchical-coordinator`, `mesh-coordinator`, `adaptive-coordinator`
506 
507### Consensus
508`byzantine-coordinator`, `raft-manager`, `gossip-coordinator`
509 
510---
511 
512## ⚙️ CONFIGURATION
513 
514### Default Swarm Config
515- Topology: `hierarchical`
516- Max Agents: 8
517- Strategy: `specialized`
518- Consensus: `raft`
519- Memory: `hybrid`
520 
521### Environment Variables
522```bash
523CLAUDE_FLOW_CONFIG=./claude-flow.config.json
524CLAUDE_FLOW_LOG_LEVEL=info
525CLAUDE_FLOW_MEMORY_BACKEND=hybrid
526```
527 
528---
529 
530## 🔗 SKILLS
531 
532Invoke with `$skill-name`:
533 
534| Skill | Purpose |
535|-------|---------|
536| `$swarm-orchestration` | Multi-agent coordination |
537| `$memory-management` | Pattern storage/retrieval |
538| `$sparc-methodology` | Structured development |
539| `$security-audit` | Security scanning |
540| `$performance-analysis` | Profiling |
541| `$github-automation` | CI/CD management |
542| `$hive-mind` | Byzantine consensus |
543| `$neural-training` | Pattern learning |
544 
545---
546 
547---
548 
549## 🔌 MCP INTEGRATION (Learning & Coordination)
550 
551Codex doesn't have native hooks like Claude Code, but uses **MCP (Model Context Protocol)** for learning and coordination.
552 
553### MCP Auto-Registration
554 
555When you run `npx claude-flow init --codex`, the MCP server is **automatically registered** with Codex.
556 
557```bash
558# Verify MCP is registered:
559codex mcp list
560 
561# Expected output:
562# Name         Command  Args                   Status
563# claude-flow  npx      claude-flow mcp start  enabled
564 
565# If not present, add manually:
566codex mcp add claude-flow -- npx claude-flow mcp start
567```
568 
569### Test MCP Connection
570```bash
571# Test MCP server starts correctly:
572npx claude-flow mcp start --test
573```
574 
575### MCP Tools Available
576Once added, Codex can use these tools via MCP:
577 
578**Coordination:**
579| Tool | Purpose |
580|------|---------|
581| `swarm_init` | Initialize swarm (topology, maxAgents) |
582| `swarm_status` | Check swarm state |
583| `agent_spawn` | Register agent roles |
584| `agent_status` | Check agent state |
585| `task_orchestrate` | Coordinate multi-agent tasks |
586 
587**Learning & Memory (USE THESE!):**
588| Tool | Purpose | When |
589|------|---------|------|
590| `memory_search` | Semantic vector search | BEFORE every task |
591| `memory_store` | Store patterns with embeddings | AFTER success |
592| `memory_retrieve` | Get by exact key | When key is known |
593| `neural_train` | Train on patterns | Periodic improvement |
594| `neural_status` | Check learning state | Debugging |
595 
596**Hive Mind (Advanced):**
597| Tool | Purpose |
598|------|---------|
599| `hive-mind_init` | Byzantine consensus swarm |
600| `hive-mind_spawn` | Spawn hive workers |
601| `hive-mind_broadcast` | Message all workers |
602 
603### Self-Learning via MCP Tools (PREFERRED)
604 
605Use MCP tools directly - faster than CLI commands:
606 
607**BEFORE starting any task - SEARCH for patterns:**
608```
609Use tool: memory_search
610  query: "keywords related to your task"
611  namespace: "patterns"
612```
613 
614**AFTER completing successfully - STORE the pattern:**
615```
616Use tool: memory_store
617  key: "pattern-[descriptive-name]"
618  value: "What worked: approach, code patterns, gotchas"
619  namespace: "patterns"
620```
621 
622### MCP Learning Workflow (Use This!)
623 
624```
6251. LEARN: memory_search(query="task keywords", namespace="patterns")
626   → If score > 0.7, USE that pattern
627 
6282. COORDINATE: swarm_init(topology="hierarchical")
629   → agent_spawn(type="coder", name="worker-1")
630 
6313. EXECUTE: YOU write the code, run commands, create files
632 
6334. REMEMBER: memory_store(key="pattern-x", value="what worked", namespace="patterns")
634```
635 
636### MCP Tools for Learning
637 
638| Tool | Purpose | When to Use |
639|------|---------|-------------|
640| `memory_search` | Find similar past patterns | BEFORE starting any task |
641| `memory_store` | Save successful patterns | AFTER completing a task |
642| `memory_retrieve` | Get specific pattern by key | When you know the exact key |
643| `neural_train` | Train on successful patterns | After multiple successes |
644 
645### Example: Learning-Enabled Task
646 
647```
648STEP 1 - LEARN:
649Use tool: memory_search
650  query: "validation utility function"
651  namespace: "patterns"
652 
653→ Found: pattern-email-validator (score: 0.82)
654→ Use this pattern as reference!
655 
656STEP 2 - COORDINATE:
657Use tool: swarm_init with topology="hierarchical", maxAgents=3
658 
659STEP 3 - EXECUTE:
660YOU create the files:
661  echo 'export function validate(x) { ... }' > /tmp/validator.js
662  node --test /tmp/validator.js
663 
664STEP 4 - REMEMBER:
665Use tool: memory_store
666  key: "pattern-phone-validator"
667  value: "Phone validation: regex /^\+?[\d\s-]{10,}$/, normalize first, test edge cases"
668  namespace: "patterns"
669```
670 
671### Vector Search Tips
672- Searches are SEMANTIC (meaning-based, not just keywords)
673- Score > 0.7 = strong match, use that pattern
674- Score 0.5-0.7 = partial match, adapt as needed
675- Store DETAILED values for better future retrieval
676 
677### CLI Fallback (if MCP unavailable)
678```bash
679npx claude-flow memory search --query "keywords" --namespace patterns
680npx claude-flow memory store --key "pattern-x" --value "what worked" --namespace patterns
681```
682 
683### Coordination via MCP
684 
685When claude-flow is added as MCP server, Codex can call tools directly:
686```
687Use tool: swarm_init with topology="hierarchical"
688Use tool: memory_store with key="result" value="success"
689```
690 
691### config.toml MCP Setup
692```toml
693# ~/.codex/config.toml
694[mcp_servers.claude-flow]
695command = "npx"
696args = ["claude-flow", "mcp", "start"]
697enabled = true
698```
699 
700---
701 
702## 📚 SUPPORT
703 
704- Docs: https://github.com/ruvnet/claude-flow
705- Issues: https://github.com/ruvnet/claude-flow/issues
706 
707**Remember: Codex executes, claude-flow orchestrates!**
708