diff --git a/.claude-plugin/marketplace.json b/.claude-plugin/marketplace.json
index 6dc119c..afa16ea 100644
--- a/.claude-plugin/marketplace.json
+++ b/.claude-plugin/marketplace.json
@@ -8,8 +8,8 @@
"plugins": [
{
"name": "oac",
- "source": "./claude-plugin",
- "description": "Ship faster with AI-powered development workflows. Automates code review, test generation, documentation, and task breakdown. Context-aware agents understand your codebase and enforce your team's standards. Works seamlessly with OpenCode, Cursor, and Windsurf.",
+ "source": "./plugins/claude-code",
+ "description": "Ship faster with AI-powered development workflows. Automates code review, test generation, documentation, and task breakdown. Context-aware agents understand your codebase and enforce your team's standards.",
"version": "1.0.0",
"author": {
"name": "darrenhinde",
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..ffd5fbd
--- /dev/null
+++ b/README.md
@@ -0,0 +1,815 @@
+
+
+
+
+# OpenAgents Control (OAC)
+
+### Control your AI patterns. Get repeatable results.
+
+**AI agents that learn YOUR coding patterns and generate matching code every time.**
+
+🎯 **Pattern Control** - Define your patterns once, AI uses them forever
+✋ **Approval Gates** - Review and approve before execution
+🔁 **Repeatable Results** - Same patterns = Same quality code
+📝 **Editable Agents** - Full control over AI behavior
+👥 **Team-Ready** - Everyone uses the same patterns
+
+**Multi-language:** TypeScript • Python • Go • Rust • Any language*
+**Model Agnostic:** Claude • GPT • Gemini • Local models
+
+
+[](https://github.com/darrenhinde/OpenAgentsControl/stargazers)
+[](https://x.com/DarrenBuildsAI)
+[](https://opensource.org/licenses/MIT)
+[](https://github.com/darrenhinde/OpenAgentsControl/commits/main)
+
+[🚀 Quick Start](#-quick-start) • [💻 Show Me Code](#-example-workflow) • [🗺️ Roadmap](https://github.com/darrenhinde/OpenAgentsControl/projects) • [💬 Community](https://nextsystems.ai)
+
+
+
+---
+
+> **Built on [OpenCode](https://opencode.ai)** - An open-source AI coding framework. OAC extends OpenCode with specialized agents, context management, and team workflows.
+
+---
+
+## The Problem
+
+Most AI agents are like hiring a developer who doesn't know your codebase. They write generic code. You spend hours rewriting, refactoring, and fixing inconsistencies. Tokens burned. Time wasted. No actual work done.
+
+**Example:**
+```typescript
+// What AI gives you (generic)
+export async function POST(request: Request) {
+ const data = await request.json();
+ return Response.json({ success: true });
+}
+
+// What you actually need (your patterns)
+export async function POST(request: Request) {
+ const body = await request.json();
+ const validated = UserSchema.parse(body); // Your Zod validation
+ const result = await db.users.create(validated); // Your Drizzle ORM
+ return Response.json(result, { status: 201 }); // Your response format
+}
+```
+
+## The Solution
+
+**OpenAgentsControl teaches agents your patterns upfront.** They understand your coding standards, your architecture, your security requirements. They propose plans before implementing. They execute incrementally with validation.
+
+**The result:** Production-ready code that ships without heavy rework.
+
+### What Makes AOC Different
+
+**🎯 Context-Aware (Your Secret Weapon)**
+Agents load YOUR patterns before generating code. Code matches your project from the start. No refactoring needed.
+
+**📝 Editable Agents (Not Baked-In Plugins)**
+Full control over agent behavior. Edit markdown files directly—no compilation, no vendor lock-in. Change workflows, add constraints, customize for your team.
+
+**✋ Approval Gates (Human-Guided AI)**
+Agents ALWAYS request approval before execution. Propose → Approve → Execute. You stay in control. No "oh no, what did the AI just do?" moments.
+
+**⚡ Token Efficient (MVI Principle)**
+Minimal Viable Information design. Only load what's needed, when it's needed. Context files <200 lines, lazy loading, faster responses.
+
+**👥 Team-Ready (Repeatable Patterns)**
+Store YOUR coding patterns once. Entire team uses same standards. Commit context to repo. New developers inherit team patterns automatically.
+
+**🔄 Model Agnostic**
+Use any AI model (Claude, GPT, Gemini, local). No vendor lock-in.
+
+**Full-stack development:** AOC handles both frontend and backend work. The agents coordinate to build complete features from UI to database.
+
+---
+
+## 🆚 Quick Comparison
+
+| Feature | OpenAgentsControl | Cursor/Copilot | Aider | Oh My OpenCode |
+|---------|-------------------|----------------|-------|----------------|
+| **Learn Your Patterns** | ✅ Built-in context system | ❌ No pattern learning | ❌ No pattern learning | ⚠️ Manual setup |
+| **Approval Gates** | ✅ Always required | ⚠️ Optional (default off) | ❌ Auto-executes | ❌ Fully autonomous |
+| **Token Efficiency** | ✅ MVI principle (80% reduction) | ❌ Full context loaded | ❌ Full context loaded | ❌ High token usage |
+| **Team Standards** | ✅ Shared context files | ❌ Per-user settings | ❌ No team support | ⚠️ Manual config per user |
+| **Edit Agent Behavior** | ✅ Markdown files you edit | ❌ Proprietary/baked-in | ⚠️ Limited prompts | ✅ Config files |
+| **Model Choice** | ✅ Any model, any provider | ⚠️ Limited options | ⚠️ OpenAI/Claude only | ✅ Multiple models |
+| **Execution Speed** | ⚠️ Sequential with approval | Fast | Fast | ✅ Parallel agents |
+| **Error Recovery** | ✅ Human-guided validation | ⚠️ Auto-retry (can loop) | ⚠️ Auto-retry | ✅ Self-correcting |
+| **Best For** | Production code, teams | Quick prototypes | Solo developers | Power users, complex projects |
+
+**Use AOC when:**
+- ✅ You have established coding patterns
+- ✅ You want code that ships without refactoring
+- ✅ You need approval gates for quality control
+- ✅ You care about token efficiency and costs
+
+**Use others when:**
+- **Cursor/Copilot:** Quick prototypes, don't care about patterns
+- **Aider:** Simple file edits, no team coordination
+- **Oh My OpenCode:** Need autonomous execution with parallel agents (speed over control)
+
+> **Full comparison:** [Read detailed analysis →](https://github.com/darrenhinde/OpenAgentsControl/discussions/116)
+
+---
+
+## 🚀 Quick Start
+
+**Prerequisites:** [OpenCode CLI](https://opencode.ai/docs) (free, open-source) • Bash 3.2+ • Git
+
+### Step 1: Install
+
+**One command:**
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/darrenhinde/OpenAgentsControl/main/install.sh | bash -s developer
+```
+
+The installer will set up OpenCode CLI if you don't have it yet.
+
+**Or interactive:**
+```bash
+curl -fsSL https://raw.githubusercontent.com/darrenhinde/OpenAgentsControl/main/install.sh -o install.sh
+bash install.sh
+```
+
+### Step 2: Start Building
+
+```bash
+opencode --agent OpenAgent
+> "Create a user authentication system"
+```
+
+### Step 3: Approve & Ship
+
+**What happens:**
+1. Agent analyzes your request
+2. Proposes a plan (you approve)
+3. Executes step-by-step with validation
+4. Delegates to specialists when needed
+5. Ships production-ready code
+
+**That's it.** Works immediately with your default model. No configuration required.
+
+---
+
+### Alternative: Claude Code Plugin (BETA)
+
+**Prefer Claude Code?** OpenAgents Control is also available as a Claude Code plugin!
+
+**Installation:**
+
+1. Register the marketplace:
+```bash
+/plugin marketplace add darrenhinde/OpenAgentsControl
+```
+
+2. Install the plugin:
+```bash
+/plugin install oac
+```
+
+3. Download context files:
+```bash
+/oac:setup --core
+```
+
+4. Start building:
+```
+Add a login endpoint
+```
+
+**Features:**
+- ✅ 6-stage workflow with approval gates
+- ✅ Context-aware code generation
+- ✅ 7 specialized subagents (task-manager, context-scout, context-manager, coder-agent, test-engineer, code-reviewer, external-scout)
+- ✅ 9 workflow skills + 6 user commands
+- ✅ Flexible context discovery (.oac config, .claude/context, context, .opencode/context)
+- ✅ Add context from GitHub, worktrees, local files, or URLs
+- ✅ Easy feature planning with `/oac:plan`
+
+**Documentation:**
+- [Plugin README](./plugins/claude-code/README.md) - Complete plugin documentation
+- [First-Time Setup](./plugins/claude-code/FIRST-TIME-SETUP.md) - Step-by-step guide
+- [Quick Start](./plugins/claude-code/QUICK-START.md) - Quick reference
+
+**Status:** BETA - Actively tested and ready for early adopters
+
+---
+
+## 💡 The Context System: Your Secret Weapon
+
+**The problem with AI code:** It doesn't match your patterns. You spend hours refactoring.
+
+**The AOC solution:** Teach your patterns once. Agents load them automatically. Code matches from the start.
+
+### How It Works
+
+```
+Your Request
+ ↓
+ContextScout discovers relevant patterns
+ ↓
+Agent loads YOUR standards
+ ↓
+Code generated using YOUR patterns
+ ↓
+Ships without refactoring ✅
+```
+
+### Add Your Patterns (10-15 Minutes)
+
+```bash
+/add-context
+```
+
+**Answer 6 simple questions:**
+1. What's your tech stack? (Next.js + TypeScript + PostgreSQL + Tailwind)
+2. Show an API endpoint example (paste your code)
+3. Show a component example (paste your code)
+4. What naming conventions? (kebab-case, PascalCase, camelCase)
+5. Any code standards? (TypeScript strict, Zod validation, etc.)
+6. Any security requirements? (validate input, parameterized queries, etc.)
+
+**Result:** Agents now generate code matching your exact patterns. No refactoring needed.
+
+### The MVI Advantage: Token Efficiency
+
+**MVI (Minimal Viable Information)** = Only load what's needed, when it's needed.
+
+**Traditional approach:**
+- Loads entire codebase context
+- Large token overhead per request
+- Slow responses, high costs
+
+**AOC approach:**
+- Loads only relevant patterns
+- Context files <200 lines (quick to load)
+- Lazy loading (agents load what they need)
+- 80% of tasks use isolation context (minimal overhead)
+
+**Real benefits:**
+- **Efficiency:** Lower token usage vs loading entire codebase
+- **Speed:** Faster responses with smaller context
+- **Quality:** Code matches your patterns (no refactoring)
+
+### For Teams: Repeatable Patterns
+
+**The team problem:** Every developer writes code differently. Inconsistent patterns. Hard to maintain.
+
+**The AOC solution:** Store team patterns in `.opencode/context/project/`. Commit to repo. Everyone uses same standards.
+
+**Example workflow:**
+```bash
+# Team lead adds patterns once
+/add-context
+# Answers questions with team standards
+
+# Commit to repo
+git add .opencode/context/
+git commit -m "Add team coding standards"
+git push
+
+# All team members now use same patterns automatically
+# New developers inherit standards on day 1
+```
+
+**Result:** Consistent code across entire team. No style debates. No refactoring PRs.
+
+---
+
+## 📖 How It Works
+
+### The Core Idea
+
+**Most AI tools:** Generic code → You refactor
+**OpenAgentsControl:** Your patterns → AI generates matching code
+
+### The Workflow
+
+```
+1. Add Your Context (one time)
+ ↓
+2. ContextScout discovers relevant patterns
+ ↓
+3. Agent loads YOUR standards
+ ↓
+4. Agent proposes plan (using your patterns)
+ ↓
+5. You approve
+ ↓
+6. Agent implements (matches your project)
+ ↓
+7. Code ships (no refactoring needed)
+```
+
+### Key Benefits
+
+**🎯 Context-Aware**
+ContextScout discovers relevant patterns. Agents load YOUR standards before generating code. Code matches your project from the start.
+
+**🔁 Repeatable**
+Same patterns → Same results. Configure once, use forever. Perfect for teams.
+
+**⚡ Token Efficient (80% Reduction)**
+MVI principle: Only load what's needed. 8,000 tokens → 750 tokens. Massive cost savings.
+
+**✋ Human-Guided**
+Agents propose plans, you approve before execution. Quality gates prevent mistakes. No auto-execution surprises.
+
+**📝 Transparent & Editable**
+Agents are markdown files you can edit. Change workflows, add constraints, customize behavior. No vendor lock-in.
+
+### What Makes This Special
+
+**1. ContextScout - Smart Pattern Discovery**
+Before generating code, ContextScout discovers relevant patterns from your context files. Ranks by priority (Critical → High → Medium). Prevents wasted work.
+
+**2. Editable Agents - Full Control**
+Unlike Cursor/Copilot where behavior is baked into plugins, AOC agents are markdown files. Edit them directly:
+```bash
+nano .opencode/agent/core/opencoder.md # local project install
+# Or: nano ~/.config/opencode/agent/core/opencoder.md # global install
+# Add project rules, change workflows, customize behavior
+```
+
+**3. ExternalScout - Live Documentation** 🆕
+Working with external libraries? ExternalScout fetches current documentation:
+- Gets live docs from official sources (npm, GitHub, docs sites)
+- No outdated training data - always current
+- Automatically triggered when agents detect external dependencies
+- Supports frameworks, APIs, libraries, and more
+
+**4. Approval Gates - No Surprises**
+Agents ALWAYS request approval before:
+- Writing/editing files
+- Running bash commands
+- Delegating to subagents
+- Making any changes
+
+You stay in control. Review plans before execution.
+
+**5. MVI Principle - Token Efficiency**
+Files designed for quick loading:
+- Concepts: <100 lines
+- Guides: <150 lines
+- Examples: <80 lines
+
+Result: Lower token usage vs loading entire codebase.
+
+**6. Team Patterns - Repeatable Results**
+Store patterns in `.opencode/context/project/`. Commit to repo. Entire team uses same standards. New developers inherit patterns automatically.
+
+---
+
+## 🎯 Which Agent Should I Use?
+
+### OpenAgent (Start Here)
+
+**Best for:** Learning the system, general tasks, quick implementations
+
+```bash
+opencode --agent OpenAgent
+> "Create a user authentication system" # Building features
+> "How do I implement authentication in Next.js?" # Questions
+> "Create a README for this project" # Documentation
+> "Explain the architecture of this codebase" # Analysis
+```
+
+**What it does:**
+- Loads your patterns via ContextScout
+- Proposes plan (you approve)
+- Executes with validation
+- Delegates to specialists when needed
+
+**Perfect for:** First-time users, simple features, learning the workflow
+
+### OpenCoder (Production Development)
+
+**Best for:** Complex features, multi-file refactoring, production systems
+
+```bash
+opencode --agent OpenCoder
+> "Create a user authentication system" # Full-stack features
+> "Refactor this codebase to use dependency injection" # Multi-file refactoring
+> "Add real-time notifications with WebSockets" # Complex implementations
+```
+
+**What it does:**
+- **Discover:** ContextScout finds relevant patterns
+- **Propose:** Detailed implementation plan
+- **Approve:** You review and approve
+- **Execute:** Incremental implementation with validation
+- **Validate:** Tests, type checking, code review
+- **Ship:** Production-ready code
+
+**Perfect for:** Production code, complex features, team development
+
+### SystemBuilder (Custom AI Systems)
+
+**Best for:** Building complete custom AI systems tailored to your domain
+
+```bash
+opencode --agent SystemBuilder
+> "Create a customer support AI system"
+```
+
+Interactive wizard generates orchestrators, subagents, context files, workflows, and commands.
+
+**Perfect for:** Creating domain-specific AI systems
+
+---
+
+## 🛠️ What's Included
+
+### 🤖 Main Agents
+- **OpenAgent** - General tasks, questions, learning (start here)
+- **OpenCoder** - Production development, complex features
+- **SystemBuilder** - Generate custom AI systems
+
+### 🔧 Specialized Subagents (Auto-delegated)
+- **ContextScout** - Smart pattern discovery (your secret weapon)
+- **TaskManager** - Breaks complex features into atomic subtasks
+- **CoderAgent** - Focused code implementations
+- **TestEngineer** - Test authoring and TDD
+- **CodeReviewer** - Code review and security analysis
+- **BuildAgent** - Type checking and build validation
+- **DocWriter** - Documentation generation
+- **ExternalScout** - Fetches live docs for external libraries (no outdated training data) **NEW!**
+- Plus category specialists: frontend, devops, copywriter, technical-writer, data-analyst
+
+### ⚡ Productivity Commands
+- `/add-context` - Interactive wizard to add your patterns
+- `/commit` - Smart git commits with conventional format
+- `/test` - Testing workflows
+- `/optimize` - Code optimization
+- `/context` - Context management
+- And 7+ more productivity commands
+
+### 📚 Context System (MVI Principle)
+Your coding standards automatically loaded by agents:
+- **Code quality** - Your patterns, security, standards
+- **UI/design** - Design system, component patterns
+- **Task management** - Workflow definitions
+- **External libraries** - Integration guides (18+ libraries supported)
+- **Project-specific** - Your team's patterns
+
+**Key features:**
+- 80% token reduction via MVI
+- Smart discovery via ContextScout
+- Lazy loading (only what's needed)
+- Team-ready (commit to repo)
+- Version controlled (track changes)
+
+### How Context Resolution Works
+
+ContextScout discovers context files using a **local-first** approach:
+
+```
+1. Check local: .opencode/context/core/navigation.md
+ ↓ Found? → Use local for everything. Done.
+ ↓ Not found?
+2. Check global: ~/.config/opencode/context/core/navigation.md
+ ↓ Found? → Use global for core/ files only.
+ ↓ Not found? → Proceed without core context.
+```
+
+**Key rules:**
+- **Local always wins** — if you installed locally, global is never checked
+- **Global fallback is only for `core/`** (standards, workflows, guides) — universal files that are the same across projects
+- **Project intelligence is always local** — your tech stack, patterns, and naming conventions live in `.opencode/context/project-intelligence/` and are never loaded from global
+- **One-time check** — ContextScout resolves the core location once at startup (max 2 glob checks), not per-file
+
+**Common setups:**
+
+| Setup | Core files from | Project intelligence from |
+|-------|----------------|--------------------------|
+| Local install (`bash install.sh developer`) | `.opencode/context/core/` | `.opencode/context/project-intelligence/` |
+| Global install + `/add-context` | `~/.config/opencode/context/core/` | `.opencode/context/project-intelligence/` |
+| Both local and global | `.opencode/context/core/` (local wins) | `.opencode/context/project-intelligence/` |
+
+---
+
+
+
+## 💻 Example Workflow
+
+```bash
+opencode --agent OpenCoder
+> "Create a user dashboard with authentication and profile settings"
+```
+
+**What happens:**
+
+**1. Discover (~1-2 min)** - ContextScout finds relevant patterns
+- Your tech stack (Next.js + TypeScript + PostgreSQL)
+- Your API pattern (Zod validation, error handling)
+- Your component pattern (functional, TypeScript, Tailwind)
+- Your naming conventions (kebab-case files, PascalCase components)
+
+**2. Propose (~2-3 min)** - Agent creates detailed implementation plan
+```
+## Proposed Implementation
+
+**Components:**
+- user-dashboard.tsx (main page)
+- profile-settings.tsx (settings component)
+- auth-guard.tsx (authentication wrapper)
+
+**API Endpoints:**
+- /api/user/profile (GET, POST)
+- /api/auth/session (GET)
+
+**Database:**
+- users table (Drizzle schema)
+- sessions table (Drizzle schema)
+
+All code will follow YOUR patterns from context.
+
+Approve? [y/n]
+```
+
+**3. Approve** - You review and approve the plan (human-guided)
+
+**4. Execute (~10-15 min)** - Incremental implementation with validation
+- Implements one component at a time
+- Uses YOUR patterns for every file
+- Validates after each step (type check, lint)
+- *This is the longest step - generating quality code takes time*
+
+**5. Validate (~2-3 min)** - Tests, type checking, code review
+- Delegates to TestEngineer for tests
+- Delegates to CodeReviewer for security check
+- Ensures production quality
+
+**6. Ship** - Production-ready code
+- Code matches your project exactly
+- No refactoring needed
+- Ready to commit and deploy
+
+**Total time: ~15-25 minutes** for a complete feature (guided, with approval gates)
+
+### 💡 Pro Tips
+
+**After finishing a feature:**
+- Run `/add-context --update` to add new patterns you discovered
+- Update your context with new libraries, conventions, or standards
+- Keep your patterns fresh as your project evolves
+
+**Working with external libraries?**
+- **ExternalScout** automatically fetches current documentation
+- No more outdated training data - gets live docs from official sources
+- Works with npm packages, APIs, frameworks, and more
+
+---
+
+## ⚙️ Advanced Configuration
+
+### Model Configuration (Optional)
+
+**By default, all agents use your OpenCode default model.** Configure models per agent only if you want different agents to use different models.
+
+**When to configure:**
+- You want faster agents to use cheaper models (e.g., Haiku/Flash)
+- You want complex agents to use smarter models (e.g., Opus/GPT-5)
+- You want to test different models for different tasks
+
+**How to configure:**
+
+Edit agent files directly:
+```bash
+nano .opencode/agent/core/opencoder.md # local project install
+# Or: nano ~/.config/opencode/agent/core/opencoder.md # global install
+```
+
+Change the model in the frontmatter:
+```yaml
+---
+description: "Development specialist"
+model: anthropic/claude-sonnet-4-5 # Change this line
+---
+```
+
+Browse available models at [models.dev](https://models.dev/?search=open) or run `opencode models`.
+
+### Update Context as You Go
+
+Your project evolves. Your context should too.
+
+```bash
+/add-context --update
+```
+
+**What gets updated:**
+- Tech stack, patterns, standards
+- Version incremented (1.0 → 1.1)
+- Updated date refreshed
+
+**Example updates:**
+- Add new library (Stripe, Twilio, etc.)
+- Change patterns (new API format, component structure)
+- Migrate tech stack (Prisma → Drizzle)
+- Update security requirements
+
+Agents automatically use updated patterns.
+
+---
+
+
+
+## 🎯 Is This For You?
+
+### ✅ Use AOC if you:
+- Build production code that ships without heavy rework
+- Work in a team with established coding standards
+- Want control over agent behavior (not black-box plugins)
+- Care about token efficiency and cost savings
+- Need approval gates for quality assurance
+- Want repeatable, consistent results
+- Use multiple AI models (no vendor lock-in)
+
+### ⚠️ Skip AOC if you:
+- Want fully autonomous execution without approval gates
+- Prefer "just do it" mode over human-guided workflows
+- Don't have established coding patterns yet
+- Need multi-agent parallelization (use Oh My OpenCode instead)
+- Want plug-and-play with zero configuration
+
+### 🤔 Not Sure?
+
+**Try this test:**
+1. Ask your current AI tool to generate an API endpoint
+2. Count how many minutes you spend refactoring it to match your patterns
+3. If you're spending time on refactoring, AOC will save you that time
+
+**Or ask yourself:**
+- Do you have coding standards your team follows?
+- Do you spend time refactoring AI-generated code?
+- Do you want AI to follow YOUR patterns, not generic ones?
+
+If you answered "yes" to any of these, AOC is for you.
+
+---
+
+## 🚀 Advanced Features
+
+### Frontend Design Workflow
+The **OpenFrontendSpecialist** follows a structured 4-stage design workflow:
+1. **Layout** - ASCII wireframe, responsive structure planning
+2. **Theme** - Design system selection, OKLCH colors, typography
+3. **Animation** - Micro-interactions, timing, accessibility
+4. **Implementation** - Single HTML file, semantic markup
+
+### Task Management & Breakdown
+The **TaskManager** breaks complex features into atomic, verifiable subtasks with smart agent suggestions and parallel execution support.
+
+### System Builder
+Build complete custom AI systems tailored to your domain in minutes. Interactive wizard generates orchestrators, subagents, context files, workflows, and commands.
+
+---
+
+## ❓ FAQ
+
+### Getting Started
+
+**Q: Does this work on Windows?**
+A: Yes! Use Git Bash (recommended) or WSL.
+
+**Q: What languages are supported?**
+A: Agents are language-agnostic and adapt based on your project files. Primarily tested with TypeScript/Node.js. Python, Go, Rust, and other languages are supported but less battle-tested. The context system works with any language.
+
+**Q: Do I need to add context?**
+A: No, but it's highly recommended. Without context, agents write generic code. With context, they write YOUR code.
+
+**Q: Can I use this without customization?**
+A: Yes, it works out of the box. But you'll get the most value after adding your patterns (10-15 minutes with `/add-context`).
+
+**Q: What models are supported?**
+A: Any model from any provider (Claude, GPT, Gemini, local models). No vendor lock-in.
+
+### For Teams
+
+**Q: How do I share context with my team?**
+A: Commit `.opencode/context/project/` to your repo. Team members automatically use same patterns.
+
+**Q: How do we ensure everyone follows the same standards?**
+A: Add team patterns to context once. All agents load them automatically. Consistent code across entire team.
+
+**Q: Can different projects have different patterns?**
+A: Yes! Use project-specific context (`.opencode/` in project root) to override global patterns.
+
+### Technical
+
+**Q: How does token efficiency work?**
+A: MVI principle: Only load what's needed, when it's needed. Context files <200 lines (scannable in 30s). ContextScout discovers relevant patterns. Lazy loading prevents context bloat. 80% of tasks use isolation context (minimal overhead).
+
+**Q: What's ContextScout?**
+A: Smart pattern discovery agent. Finds relevant context files before code generation. Ranks by priority. Prevents wasted work.
+
+**Q: Can I edit agent behavior?**
+A: Yes! Agents are markdown files. Edit them directly: `nano .opencode/agent/core/opencoder.md` (local) or `nano ~/.config/opencode/agent/core/opencoder.md` (global)
+
+**Q: How do approval gates work?**
+A: Agents ALWAYS request approval before execution (write/edit/bash). You review plans before implementation. No surprises.
+
+**Q: How do I update my context?**
+A: Run `/add-context --update` anytime your patterns change. Agents automatically use updated patterns.
+
+### Comparison
+
+**Q: How is this different from Cursor/Copilot?**
+A: AOC has editable agents (not baked-in), approval gates (not auto-execute), context system (YOUR patterns), and MVI token efficiency.
+
+**Q: How is this different from Aider?**
+A: AOC has team patterns, context system, approval workflow, and smart pattern discovery. Aider is file-based only.
+
+**Q: How does this compare to Oh My OpenCode?**
+A: Both are built on OpenCode. AOC focuses on **control & repeatability** (approval gates, pattern control, team standards). Oh My OpenCode focuses on **autonomy & speed** (parallel agents, auto-execution). [Read detailed comparison →](https://github.com/darrenhinde/OpenAgentsControl/discussions/116)
+
+**Q: When should I NOT use AOC?**
+A: If you want fully autonomous execution without approval gates, or if you don't have established coding patterns yet.
+
+### Setup
+
+**Q: What bash version do I need?**
+A: Bash 3.2+ (macOS default works). Run `bash scripts/tests/test-compatibility.sh` to check.
+
+**Q: Do I need to install plugins/tools?**
+A: No, they're optional. Only install if you want Telegram notifications or Gemini AI features.
+
+**Q: Where should I install - globally or per-project?**
+A: Local (`.opencode/` in your project) is recommended — patterns are committed to git and shared with your team. Global (`~/.config/opencode/`) is good for personal defaults across all projects. The installer asks you to choose. See [OpenCode Config Docs](https://opencode.ai/docs/config/) for how configs merge.
+
+---
+
+## 🗺️ Roadmap & What's Coming
+
+**This is only the beginning!** We're actively developing new features and improvements every day.
+
+### 🚀 See What's Coming Next
+
+Check out our [**Project Board**](https://github.com/darrenhinde/OpenAgentsControl/projects) to see:
+- 🔨 **In Progress** - Features being built right now
+- 📋 **Planned** - What's coming soon
+- 💡 **Ideas** - Future enhancements under consideration
+- ✅ **Recently Shipped** - Latest improvements
+
+### 🎯 Current Focus Areas
+
+- **Plugin System** - npm-based plugin architecture for easy distribution
+- **Performance Improvements** - Faster agent execution and context loading
+- **Enhanced Context Discovery** - Smarter pattern recognition
+- **Multi-language Support** - Better Python, Go, Rust support
+- **Team Collaboration** - Shared context and team workflows
+- **Documentation** - More examples, tutorials, and guides
+
+### 💬 Have Ideas?
+
+We'd love to hear from you!
+- 💡 [**Submit Feature Requests**](https://github.com/darrenhinde/OpenAgentsControl/issues/new?labels=enhancement)
+- 🐛 [**Report Bugs**](https://github.com/darrenhinde/OpenAgentsControl/issues/new?labels=bug)
+- 💬 [**Join Discussions**](https://github.com/darrenhinde/OpenAgentsControl/discussions)
+
+**Star the repo** ⭐ to stay updated with new releases!
+
+---
+
+## 🤝 Contributing
+
+We welcome contributions!
+
+1. Follow the established naming conventions and coding standards
+2. Write comprehensive tests for new features
+3. Update documentation for any changes
+4. Ensure security best practices are followed
+
+See: [Contributing Guide](docs/contributing/CONTRIBUTING.md) • [Code of Conduct](docs/contributing/CODE_OF_CONDUCT.md)
+
+---
+
+## 💬 Community & Support
+
+
+
+**Join the community and stay updated with the latest AI development workflows!**
+
+[](https://youtube.com/@DarrenBuildsAI)
+[](https://nextsystems.ai)
+[](https://x.com/DarrenBuildsAI)
+[](https://buymeacoffee.com/darrenhinde)
+
+**📺 Tutorials & Demos** • **💬 Join Waitlist** • **🐦 Latest Updates** • **☕ Support Development**
+
+*Your support helps keep this project free and open-source!*
+
+
+
+---
+
+## License
+
+This project is licensed under the MIT License.
+
+---
+
+**Made with ❤️ by developers, for developers. Star the repo if this saves you refactoring time!**
diff --git a/claude-plugin/INSTALL.md b/claude-plugin/INSTALL.md
deleted file mode 100644
index bfb23cc..0000000
--- a/claude-plugin/INSTALL.md
+++ /dev/null
@@ -1,102 +0,0 @@
-# OAC Plugin - Installation Guide
-
-Quick guide to install and test the OAC (OpenAgents Control) plugin for Claude Code.
-
-## 🚀 Quick Install
-
-### Method 1: From GitHub (After Push)
-
-```bash
-# Add the marketplace
-/plugin marketplace add darrenhinde/OpenAgentsControl
-
-# Install the plugin
-/plugin install oac
-
-# Verify it works
-/oac:hello
-```
-
-### Method 2: Local Development (Now)
-
-```bash
-# Navigate to the repo
-cd /path/to/OpenAgentsControl
-
-# Start Claude with the plugin
-claude --plugin-dir ./claude-plugin
-
-# In Claude Code, test the plugin
-/oac:hello
-```
-
-## 📋 Verification Steps
-
-After installation, verify everything works:
-
-1. **Check plugin is loaded**:
- ```bash
- /plugin list
- ```
- You should see "oac" in the list.
-
-2. **Test the hello skill**:
- ```bash
- /oac:hello
- ```
- You should get a friendly response confirming the plugin is working.
-
-3. **Check available commands**:
- ```bash
- /help
- ```
- Look for `/oac:*` commands.
-
-## 🔧 Troubleshooting
-
-### Plugin not found
-- Make sure you're in the correct directory
-- Check that `claude-plugin/.claude-plugin/plugin.json` exists
-- Verify the symlink: `ls -la claude-plugin/context`
-
-### Skill not working
-- Check the skill file exists: `claude-plugin/skills/hello/SKILL.md`
-- Restart Claude Code
-- Try: `claude --plugin-dir ./claude-plugin --verbose`
-
-### Context not loading
-- Verify symlink: `cd claude-plugin && ls -la context`
-- Should point to: `../.opencode/context`
-- Check context files exist: `ls .opencode/context/`
-
-## 📦 What Gets Installed
-
-When you install the plugin, Claude Code copies:
-
-```
-~/.claude/plugins/cache/oac/
-├── .claude-plugin/plugin.json
-├── skills/hello/SKILL.md
-├── context/ (symlink content)
-├── agents/ (empty for now)
-├── hooks/ (empty for now)
-└── commands/ (empty for now)
-```
-
-## 🎯 Next Steps
-
-After successful installation:
-
-1. **Explore the context**: The plugin has access to all OpenAgents Control context files
-2. **Wait for more skills**: Code review, testing, documentation skills coming soon
-3. **Contribute**: Add your own skills to `claude-plugin/skills/`
-
-## 🆘 Need Help?
-
-- **Issues**: https://github.com/darrenhinde/OpenAgentsControl/issues
-- **Discussions**: https://github.com/darrenhinde/OpenAgentsControl/discussions
-
----
-
-**Version**: 1.0.0
-**Last Updated**: 2026-02-16
diff --git a/claude-plugin/QUICK-START.md b/claude-plugin/QUICK-START.md
deleted file mode 100644
index 5d51012..0000000
--- a/claude-plugin/QUICK-START.md
+++ /dev/null
@@ -1,180 +0,0 @@
-# OAC Plugin - Quick Start
-
-**Status**: ✅ Ready to test locally
-**Version**: 1.0.0
-**Date**: 2026-02-16
-
----
-
-## ✅ What's Been Created
-
-```
-OpenAgentsControl/
-├── .claude-plugin/
-│ └── marketplace.json # Marketplace catalog
-│
-└── claude-plugin/
- ├── .claude-plugin/
- │ └── plugin.json # Plugin manifest (name: "oac")
- ├── skills/
- │ └── hello/
- │ └── SKILL.md # Test skill
- ├── agents/ # (empty - ready for future agents)
- ├── hooks/ # (empty - ready for future hooks)
- ├── commands/ # (empty - ready for future commands)
- ├── context -> ../.opencode/context/ # Symlink to shared context
- ├── README.md # Full documentation
- ├── INSTALL.md # Installation guide
- └── QUICK-START.md # This file
-```
-
----
-
-## 🚀 Test It Now (Local)
-
-```bash
-# 1. Make sure you're in the repo root
-cd /path/to/OpenAgentsControl
-
-# 2. Start Claude with the plugin
-claude --plugin-dir ./claude-plugin
-
-# 3. In Claude Code, test the plugin
-/oac:hello
-```
-
-**Expected output**: A friendly message confirming the OAC plugin is working.
-
----
-
-## 📦 Publish to GitHub (Next Step)
-
-Once you've tested locally and it works:
-
-```bash
-# 1. Add the files
-git add claude-plugin/ .claude-plugin/
-
-# 2. Commit
-git commit -m "feat: add Claude Code plugin (OAC)"
-
-# 3. Push
-git push origin main
-
-# 4. Users can then install via marketplace
-# /plugin marketplace add darrenhinde/OpenAgentsControl
-# /plugin install oac
-```
-
----
-
-## 🎯 Available Commands (After Install)
-
-- `/oac:hello` - Test skill to verify plugin is working
-
----
-
-## 🔜 Coming Soon
-
-### Skills to Add
-- `/oac:code-review` - Intelligent code review
-- `/oac:test` - TDD-driven test creation
-- `/oac:docs` - Documentation generation
-- `/oac:task-breakdown` - Feature decomposition
-- `/oac:context-scout` - Smart context discovery
-
-### Hooks to Add
-- Auto-format on file write
-- Auto-commit after changes
-- Test runner on save
-- Documentation sync
-
-### Agents to Add
-- Code Reviewer
-- Test Engineer
-- Doc Writer
-- Task Manager
-
----
-
-## 📝 How to Add More Skills
-
-1. **Create skill directory**:
- ```bash
- mkdir -p claude-plugin/skills/my-skill
- ```
-
-2. **Create SKILL.md**:
- ```markdown
- # My Skill
-
- Description of what this skill does.
-
- ```claude
- You are a helpful assistant that...
- ```
- ```
-
-3. **Test it**:
- ```bash
- claude --plugin-dir ./claude-plugin
- /oac:my-skill
- ```
-
-4. **Commit and push**:
- ```bash
- git add claude-plugin/skills/my-skill/
- git commit -m "feat: add my-skill to OAC plugin"
- git push
- ```
-
----
-
-## 🔗 Key Files
-
-| File | Purpose |
-|------|---------|
-| `claude-plugin/.claude-plugin/plugin.json` | Plugin metadata (name, version, etc.) |
-| `claude-plugin/skills/*/SKILL.md` | Skill definitions |
-| `claude-plugin/context` | Symlink to shared context |
-| `.claude-plugin/marketplace.json` | Marketplace catalog |
-
----
-
-## 🆘 Troubleshooting
-
-### "Plugin not found"
-- Check you're in the repo root
-- Verify: `ls claude-plugin/.claude-plugin/plugin.json`
-
-### "Skill not working"
-- Check: `ls claude-plugin/skills/hello/SKILL.md`
-- Restart Claude Code
-
-### "Context not loading"
-- Verify symlink: `ls -la claude-plugin/context`
-- Should show: `context -> ../.opencode/context`
-
----
-
-## 📚 Documentation
-
-- **Full README**: `claude-plugin/README.md`
-- **Installation Guide**: `claude-plugin/INSTALL.md`
-- **Main Repo Docs**: `.opencode/docs/`
-- **Planning Docs**: `docs/planning/`
-
----
-
-## ✅ Next Steps
-
-1. **Test locally** (see above)
-2. **Add more skills** (code-review, test, docs)
-3. **Push to GitHub**
-4. **Share with users**
-
----
-
-**Ready to test!** 🎉
-
-Run: `claude --plugin-dir ./claude-plugin` and then `/oac:hello`
diff --git a/claude-plugin/README.md b/claude-plugin/README.md
deleted file mode 100644
index f314754..0000000
--- a/claude-plugin/README.md
+++ /dev/null
@@ -1,169 +0,0 @@
-# OAC - Claude Code Plugin
-
-OpenAgents Control (OAC) - Multi-agent orchestration and automation for Claude Code.
-
-## 🎯 Overview
-
-OpenAgents Control brings powerful multi-agent capabilities to Claude Code, including:
-
-- **Intelligent Code Review** - Automated code quality and security analysis
-- **Test Engineering** - TDD-driven test creation and validation
-- **Documentation** - Automated documentation generation and maintenance
-- **Task Management** - Break down complex features into manageable tasks
-- **Context Discovery** - Smart context file discovery and loading
-
-## 📦 Installation
-
-### Option 1: From Marketplace (Recommended)
-
-```bash
-# Add the OpenAgents Control marketplace
-/plugin marketplace add darrenhinde/OpenAgentsControl
-
-# Install the plugin
-/plugin install oac
-```
-
-### Option 2: Local Development
-
-```bash
-# Clone the repo
-git clone https://github.com/darrenhinde/OpenAgentsControl.git
-cd OpenAgentsControl
-
-# Load plugin locally
-claude --plugin-dir ./claude-plugin
-```
-
-## 🚀 Quick Start
-
-After installation, test the plugin:
-
-```bash
-# Verify installation
-/oac:hello
-```
-
-## 📚 Available Skills
-
-### Current Skills
-
-- **hello** - Test skill to verify plugin installation
-
-### Coming Soon
-
-- **code-review** - Intelligent code review with security and quality checks
-- **test-engineer** - TDD-driven test creation
-- **doc-writer** - Documentation generation
-- **task-breakdown** - Feature decomposition into tasks
-- **context-scout** - Smart context discovery
-
-## 🔧 Configuration
-
-The plugin uses shared context from the main OpenAgents Control repository via symlinks.
-
-### Context Structure
-
-```
-claude-plugin/
-├── .claude-plugin/plugin.json
-├── skills/ # Claude-specific skills
-├── agents/ # Claude-specific agents
-├── hooks/ # Event-driven automation
-├── commands/ # Custom slash commands
-└── context -> ../.opencode/context/ # Symlinked shared context
-```
-
-## 🛠️ Development
-
-### Adding New Skills
-
-1. Create skill directory:
- ```bash
- mkdir -p claude-plugin/skills/my-skill
- ```
-
-2. Create `SKILL.md`:
- ```markdown
- # My Skill
-
- Description of what this skill does.
-
- ```claude
- You are a helpful assistant that...
- ```
- ```
-
-3. Test locally:
- ```bash
- claude --plugin-dir ./claude-plugin
- /oac:my-skill
- ```
-
-### Adding Hooks
-
-Create `hooks/hooks.json`:
-
-```json
-{
- "hooks": {
- "PostToolUse": [{
- "matcher": "Write|Edit",
- "hooks": [{
- "type": "command",
- "command": "${CLAUDE_PLUGIN_ROOT}/scripts/format.sh",
- "timeout": 30
- }]
- }]
- }
-}
-```
-
-## 🔗 Related Projects
-
-- **OpenAgents Control** - Main repository (OpenCode native)
-- **OAC CLI** - Command-line tool for multi-IDE management (coming soon)
-
-## 📖 Documentation
-
-- [Main Documentation](../.opencode/docs/)
-- [Context System](../docs/context-system/)
-- [Planning Documents](../docs/planning/)
-
-## 🤝 Contributing
-
-Contributions welcome! See the main [OpenAgents Control repository](https://github.com/darrenhinde/OpenAgentsControl) for contribution guidelines.
-
-## 📄 License
-
-MIT License - see [LICENSE](../LICENSE) for details.
-
-## 🆘 Support
-
-- **Issues**: [GitHub Issues](https://github.com/darrenhinde/OpenAgentsControl/issues)
-- **Discussions**: [GitHub Discussions](https://github.com/darrenhinde/OpenAgentsControl/discussions)
-
-## 🗺️ Roadmap
-
-### Phase 1: Foundation (Current)
-- ✅ Plugin structure
-- ✅ Marketplace catalog
-- ✅ Test skill
-- ⬜ Core skills (code-review, test-engineer, doc-writer)
-
-### Phase 2: Advanced Features
-- ⬜ Hooks for automation
-- ⬜ MCP server integration
-- ⬜ Custom commands
-- ⬜ Agent delegation
-
-### Phase 3: JSON Config System
-- ⬜ Auto-generation from JSON config
-- ⬜ Type-safe configuration
-- ⬜ Multi-IDE conversion
-
----
-
-**Version**: 1.0.0
-**Last Updated**: 2026-02-16
-**Status**: Active Development
diff --git a/claude-plugin/context b/claude-plugin/context
deleted file mode 120000
index fd8f278..0000000
--- a/claude-plugin/context
+++ /dev/null
@@ -1 +0,0 @@
-../.opencode/context
\ No newline at end of file
diff --git a/claude-plugin/skills/hello/SKILL.md b/claude-plugin/skills/hello/SKILL.md
deleted file mode 100644
index 08c1d90..0000000
--- a/claude-plugin/skills/hello/SKILL.md
+++ /dev/null
@@ -1,15 +0,0 @@
-# Hello
-
-A simple test skill to verify OpenAgents Control plugin is working.
-
-```claude
-You are a helpful assistant from the OpenAgents Control plugin.
-
-When invoked, you should:
-1. Confirm that the OpenAgents Control plugin is successfully installed and working
-2. Briefly explain what OpenAgents Control provides (multi-agent orchestration, automation, code review, testing)
-3. List a few example commands users can try (once more skills are added)
-4. Be friendly and encouraging
-
-Keep your response concise (2-3 sentences).
-```
diff --git a/hello.txt b/hello.txt
deleted file mode 100644
index 05a682b..0000000
--- a/hello.txt
+++ /dev/null
@@ -1 +0,0 @@
-Hello!
\ No newline at end of file
diff --git a/plugins/README.md b/plugins/README.md
new file mode 100644
index 0000000..d63a1f4
--- /dev/null
+++ b/plugins/README.md
@@ -0,0 +1,65 @@
+# OpenAgents Control - IDE Plugins
+
+This directory contains IDE-specific plugin implementations for OpenAgents Control.
+
+## Structure
+
+```
+plugins/
+└── claude-code/ # Claude Code plugin
+ ├── .claude-plugin/ # Plugin manifest
+ ├── skills/ # Claude-specific skills
+ ├── agents/ # Claude-specific agents
+ ├── hooks/ # Event-driven automation
+ ├── commands/ # Custom slash commands
+ ├── context/ # Symlink to .opencode/context/
+ └── README.md # Plugin documentation
+```
+
+## Available Plugins
+
+### Claude Code (`claude-code/`)
+
+**Plugin Name**: `oac`
+
+**Installation**:
+```bash
+# From GitHub marketplace
+/plugin marketplace add darrenhinde/OpenAgentsControl
+/plugin install oac
+
+# Local testing
+claude --plugin-dir ./plugins/claude-code
+```
+
+**Features**:
+- Intelligent code review with security analysis
+- TDD test generation
+- Automated documentation
+- Smart task breakdown
+- Context-aware agents
+
+**Documentation**: See `claude-code/README.md`
+
+## Future Plugins
+
+- **Cursor** - Planned
+- **Windsurf** - Planned
+- **VS Code** - Planned
+
+## Development
+
+Each plugin is self-contained and can be developed/tested independently.
+
+### Adding a New Plugin
+
+1. Create plugin directory: `plugins/your-ide/`
+2. Add plugin manifest (IDE-specific format)
+3. Symlink to shared context: `ln -s ../../.opencode/context context`
+4. Add skills/agents/commands
+5. Update `.claude-plugin/marketplace.json` if applicable
+6. Document in plugin's README.md
+
+---
+
+**Last Updated**: 2026-02-16
diff --git a/claude-plugin/.claude-plugin/plugin.json b/plugins/claude-code/.claude-plugin/plugin.json
similarity index 56%
rename from claude-plugin/.claude-plugin/plugin.json
rename to plugins/claude-code/.claude-plugin/plugin.json
index 1856172..0264355 100644
--- a/claude-plugin/.claude-plugin/plugin.json
+++ b/plugins/claude-code/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
{
"name": "oac",
- "description": "AI development workflow automation for Claude Code - intelligent code review, TDD test generation, automated documentation, and smart task breakdown",
+ "description": "OpenAgents Control - Intelligent code review, TDD test generation, automated documentation, and smart task breakdown with context-aware AI agents",
"version": "1.0.0",
"author": {
"name": "darrenhinde",
diff --git a/plugins/claude-code/.context-manifest.json b/plugins/claude-code/.context-manifest.json
new file mode 100644
index 0000000..2ae6ef6
--- /dev/null
+++ b/plugins/claude-code/.context-manifest.json
@@ -0,0 +1,11 @@
+{
+ "version": "1.0.0",
+ "source": {
+ "repository": "github:darrenhinde/OpenAgentsControl#main",
+ "branch": null,
+ "commit": null,
+ "downloaded_at": null
+ },
+ "categories": [],
+ "files": {}
+}
diff --git a/plugins/claude-code/.oac.example b/plugins/claude-code/.oac.example
new file mode 100644
index 0000000..2759fe1
--- /dev/null
+++ b/plugins/claude-code/.oac.example
@@ -0,0 +1,26 @@
+# OpenAgents Control Configuration
+# Copy this file to .oac in your project root or ~/.oac for global settings
+# Format: YAML-like key-value pairs (simple parsing, no external dependencies)
+
+version: "1.0"
+
+# Context settings
+context.auto_download: false
+context.categories: core,openagents-repo
+context.update_check: true
+context.cache_days: 7
+
+# Cleanup settings
+cleanup.auto_prompt: true
+cleanup.session_days: 7
+cleanup.task_days: 30
+cleanup.external_days: 7
+
+# Workflow settings
+workflow.auto_approve: false
+workflow.verbose: false
+
+# External scout settings
+external_scout.enabled: true
+external_scout.cache_enabled: true
+external_scout.sources: context7
diff --git a/plugins/claude-code/FIRST-TIME-SETUP.md b/plugins/claude-code/FIRST-TIME-SETUP.md
new file mode 100644
index 0000000..bc452e2
--- /dev/null
+++ b/plugins/claude-code/FIRST-TIME-SETUP.md
@@ -0,0 +1,589 @@
+# OAC Plugin - First-Time Setup Guide
+
+**Version**: 1.0.0
+**Date**: 2026-02-16
+**Audience**: First-time users
+**Time**: 5-10 minutes
+
+---
+
+## 🎯 What You'll Accomplish
+
+By the end of this guide, you'll have:
+- ✅ OAC plugin installed and verified
+- ✅ Context files downloaded
+- ✅ Working development workflow
+- ✅ Understanding of the 6-stage process
+
+**No prior experience needed** — just follow the steps in order.
+
+---
+
+## 📋 Prerequisites
+
+Before starting, ensure you have:
+- [ ] Claude Code installed and working
+- [ ] Internet connection (for downloading context files)
+- [ ] A project directory to work in
+
+---
+
+## 🚀 Step-by-Step Setup
+
+### Step 1: Install the Plugin
+
+**Choose ONE method:**
+
+#### Option A: From GitHub Marketplace (Recommended)
+
+```bash
+# Add the marketplace
+/plugin marketplace add darrenhinde/OpenAgentsControl
+
+# Install the plugin
+/plugin install oac
+```
+
+**Expected output**:
+```
+✓ Marketplace added: darrenhinde/OpenAgentsControl
+✓ Plugin installed: oac
+✓ Location: ~/.claude/plugins/cache/oac/
+```
+
+#### Option B: Local Development
+
+```bash
+# Navigate to the repo
+cd /path/to/OpenAgentsControl
+
+# Start Claude with the plugin
+claude --plugin-dir ./plugins/claude-code
+```
+
+**Expected output**:
+```
+✓ Loading plugin from: ./plugins/claude-code
+✓ Plugin loaded: oac
+```
+
+---
+
+### Step 2: Verify Installation
+
+Run the status command to check everything is working:
+
+```bash
+/oac:status
+```
+
+**Expected output**:
+```
+OAC Plugin Status
+=================
+
+Plugin Version: 1.0.0
+Status: ✅ Installed
+
+Components:
+- Subagents: 6 available
+ ✓ task-manager
+ ✓ context-scout
+ ✓ external-scout
+ ✓ coder-agent
+ ✓ test-engineer
+ ✓ code-reviewer
+
+- Skills: 9 available
+ ✓ using-oac
+ ✓ context-discovery
+ ✓ external-scout
+ ✓ task-breakdown
+ ✓ code-execution
+ ✓ test-generation
+ ✓ code-review
+ ✓ context-manager
+ ✓ parallel-execution
+
+- Commands: 4 available
+ ✓ /oac:setup
+ ✓ /oac:help
+ ✓ /oac:status
+ ✓ /oac:cleanup
+
+Context Files: ⚠️ Not installed yet
+```
+
+**✅ Success indicator**: You should see "Plugin Version: 1.0.0" and all components listed.
+
+**❌ If you see errors**: See [Troubleshooting](#troubleshooting) section below.
+
+---
+
+### Step 3: Download Context Files
+
+Context files contain coding standards, security patterns, and workflow guides that OAC uses to ensure high-quality code.
+
+**Choose ONE option:**
+
+#### Option A: Core Context Only (Recommended for First-Time Users)
+
+```bash
+/oac:setup --core
+```
+
+**What this downloads**: ~50 essential files (standards, workflows, patterns)
+**Download time**: 30-60 seconds
+**Disk space**: ~2 MB
+
+**Expected output**:
+```
+Downloading OAC Context Files
+==============================
+
+Category: core
+Source: https://github.com/darrenhinde/OpenAgentsControl
+
+Downloading files...
+✓ .opencode/context/core/standards/code-quality.md
+✓ .opencode/context/core/standards/security-patterns.md
+✓ .opencode/context/core/standards/typescript.md
+✓ .opencode/context/core/workflows/6-stage-workflow.md
+... (46 more files)
+
+Summary:
+========
+✓ Downloaded: 50 files
+✓ Location: .opencode/context/
+✓ Manifest: plugins/claude-code/.context-manifest.json
+
+Next steps:
+- Run /oac:status to verify
+- Start coding with /using-oac
+```
+
+#### Option B: All Context (For Advanced Users)
+
+```bash
+/oac:setup --all
+```
+
+**What this downloads**: ~200 files (includes examples, guides, plugin docs)
+**Download time**: 2-3 minutes
+**Disk space**: ~8 MB
+
+---
+
+### Step 4: Verify Context Installation
+
+Check that context files were downloaded successfully:
+
+```bash
+/oac:status
+```
+
+**Expected output**:
+```
+OAC Plugin Status
+=================
+
+Plugin Version: 1.0.0
+Status: ✅ Installed
+
+Context Files: ✅ Installed
+- Version: 1.0.0
+- Location: .opencode/context/
+- Files: 50 (core)
+- Last updated: 2026-02-16
+
+Components:
+... (same as before)
+```
+
+**✅ Success indicator**: "Context Files: ✅ Installed"
+
+**You can also verify manually**:
+```bash
+# Check that context directory exists
+ls .opencode/context/
+
+# Should show:
+# core/ openagents-repo/ navigation.md
+```
+
+---
+
+### Step 5: View Available Features
+
+Get an overview of what OAC can do:
+
+```bash
+/oac:help
+```
+
+**Expected output**: A comprehensive guide showing:
+- 6-stage workflow overview
+- Available skills and when to use them
+- Available subagents and their purposes
+- Available commands
+- Quick start examples
+
+**Take 2 minutes to skim this output** — it's your reference guide.
+
+---
+
+### Step 6: Test the Workflow
+
+Let's test OAC with a simple task to ensure everything works.
+
+**Type this into Claude Code**:
+```
+Add a hello world function to a new file called utils.ts
+```
+
+**What should happen**:
+
+1. **Stage 1: Analyze & Discover**
+ ```
+ I'll help you add a hello world function. Let me discover relevant context first.
+
+ Invoking /context-discovery to find coding standards...
+ ```
+
+2. **Stage 2: Plan & Approve**
+ ```
+ Plan:
+ - Create src/utils.ts
+ - Add helloWorld() function
+ - Follow TypeScript standards from context
+
+ Files to create:
+ - src/utils.ts
+
+ May I proceed with this plan? (yes/no)
+ ```
+
+ **Type**: `yes`
+
+3. **Stage 3: LoadContext**
+ ```
+ Loading context files...
+ ✓ Read .opencode/context/core/standards/typescript.md
+ ✓ Read .opencode/context/core/standards/code-quality.md
+ ```
+
+4. **Stage 4: Execute**
+ ```
+ Creating src/utils.ts...
+ ✓ File created with helloWorld() function
+ ```
+
+5. **Stage 5: Validate**
+ ```
+ Validating implementation...
+ ✓ TypeScript syntax valid
+ ✓ Follows coding standards
+ ✓ No anti-patterns detected
+ ```
+
+6. **Stage 6: Complete**
+ ```
+ ✅ Task completed successfully!
+
+ Summary:
+ - Created src/utils.ts
+ - Added helloWorld() function
+ - Follows TypeScript standards
+ ```
+
+**✅ Success indicator**: You should see all 6 stages complete without errors.
+
+---
+
+## 🎓 Understanding the 6-Stage Workflow
+
+Every task in OAC follows this workflow:
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│ Stage 1: Analyze & Discover │
+│ - Understand what you're asking for │
+│ - Find relevant context files (standards, patterns) │
+└─────────────────────────────────────────────────────────────┘
+ ↓
+┌─────────────────────────────────────────────────────────────┐
+│ Stage 2: Plan & Approve │
+│ - Present implementation plan │
+│ - REQUEST APPROVAL before proceeding │
+│ - Confirm approach with you │
+└─────────────────────────────────────────────────────────────┘
+ ↓
+┌─────────────────────────────────────────────────────────────┐
+│ Stage 3: LoadContext │
+│ - Read all discovered context files │
+│ - Load coding standards, security patterns │
+│ - Pre-load everything needed for execution │
+└─────────────────────────────────────────────────────────────┘
+ ↓
+┌─────────────────────────────────────────────────────────────┐
+│ Stage 4: Execute │
+│ - Simple tasks (1-3 files): Direct implementation │
+│ - Complex tasks (4+ files): Break down into subtasks │
+│ - Follow loaded standards and patterns │
+└─────────────────────────────────────────────────────────────┘
+ ↓
+┌─────────────────────────────────────────────────────────────┐
+│ Stage 5: Validate │
+│ - Run tests and validation │
+│ - STOP on failure — fix before proceeding │
+│ - Verify acceptance criteria met │
+└─────────────────────────────────────────────────────────────┘
+ ↓
+┌─────────────────────────────────────────────────────────────┐
+│ Stage 6: Complete │
+│ - Update documentation │
+│ - Summarize changes │
+│ - Return results │
+└─────────────────────────────────────────────────────────────┘
+```
+
+**Key points**:
+- **Approval gate at Stage 2** — You control what gets implemented
+- **Context loaded upfront** — Ensures consistent, high-quality code
+- **Validation before completion** — Catches issues early
+- **Automatic for every task** — You don't need to invoke it manually
+
+---
+
+## 🎯 What's Next?
+
+Now that OAC is set up, you can:
+
+### 1. Start Building Features
+
+Just describe what you want to build:
+```
+Build a user authentication system with JWT tokens
+```
+
+OAC will:
+- Discover relevant security patterns
+- Break down into subtasks (if complex)
+- Implement following best practices
+- Generate tests
+- Review code quality
+
+### 2. Explore Advanced Features
+
+**Context Manager** — Set up project-specific configuration:
+```
+/context-manager
+```
+
+**Parallel Execution** — Speed up multi-component features:
+```
+# Automatically used when tasks are independent
+# Example: Frontend + Backend + Tests run simultaneously
+```
+
+**External Scout** — Fetch current library documentation:
+```
+/external-scout drizzle schemas
+/external-scout react hooks
+```
+
+### 3. Learn the Skills
+
+Each skill has a specific purpose:
+
+| Skill | When to Use |
+|-------|-------------|
+| `/using-oac` | Auto-invoked for every task |
+| `/context-discovery` | Find relevant standards and patterns |
+| `/external-scout` | Get current library documentation |
+| `/task-breakdown` | Break down complex features |
+| `/code-execution` | Implement features |
+| `/test-generation` | Create comprehensive tests |
+| `/code-review` | Review code quality |
+| `/context-manager` | Set up projects and configuration |
+| `/parallel-execution` | Execute independent tasks simultaneously |
+
+### 4. Read the Documentation
+
+- **Quick Start**: `QUICK-START.md` — Usage examples and workflows
+- **Installation**: `INSTALL.md` — Detailed installation guide
+- **Full README**: `README.md` — Complete system overview
+
+---
+
+## 🆘 Troubleshooting
+
+### Issue: Plugin not found
+
+**Symptom**: `/oac:status` returns "command not found"
+
+**Solution**:
+```bash
+# Check plugin list
+/plugin list
+
+# Should show "oac" in the list
+# If not, reinstall:
+/plugin install oac
+```
+
+---
+
+### Issue: Context files not downloading
+
+**Symptom**: `/oac:setup --core` fails or times out
+
+**Solution**:
+```bash
+# Check internet connection
+ping github.com
+
+# Try again with verbose output
+/oac:setup --core --verbose
+
+# If still failing, check GitHub access
+curl https://raw.githubusercontent.com/darrenhinde/OpenAgentsControl/main/README.md
+```
+
+---
+
+### Issue: Skills not working
+
+**Symptom**: `/context-discovery` returns "skill not found"
+
+**Solution**:
+```bash
+# Verify skill files exist
+ls ~/.claude/plugins/cache/oac/skills/
+
+# Should show 9 directories
+# If missing, reinstall plugin
+/plugin uninstall oac
+/plugin install oac
+```
+
+---
+
+### Issue: Subagents not available
+
+**Symptom**: Error when trying to invoke subagent
+
+**Solution**:
+```bash
+# Check status
+/oac:status
+
+# Should show 6 subagents
+# If missing, verify agent files
+ls ~/.claude/plugins/cache/oac/agents/
+
+# Should show 6 .md files
+# If missing, reinstall plugin
+```
+
+---
+
+### Issue: Workflow not auto-starting
+
+**Symptom**: Tasks don't automatically invoke `/using-oac`
+
+**Solution**:
+```bash
+# Check hooks are installed
+ls ~/.claude/plugins/cache/oac/hooks/
+
+# Should show:
+# - hooks.json
+# - session-start.sh
+
+# Restart Claude Code to reload hooks
+```
+
+---
+
+### Issue: Context files exist but not being used
+
+**Symptom**: OAC says "context not found" but files exist
+
+**Solution**:
+```bash
+# Verify context location
+ls .opencode/context/core/standards/
+
+# Should show multiple .md files
+
+# Check manifest
+cat plugins/claude-code/.context-manifest.json
+
+# Should show version and file list
+
+# If manifest missing, re-run setup
+/oac:setup --core --force
+```
+
+---
+
+## ✅ Success Checklist
+
+Before you finish, verify:
+
+- [ ] `/oac:status` shows "Plugin Version: 1.0.0"
+- [ ] `/oac:status` shows "Context Files: ✅ Installed"
+- [ ] `/oac:status` shows 6 subagents, 9 skills, 4 commands
+- [ ] `.opencode/context/` directory exists with files
+- [ ] Test task completed successfully (hello world example)
+- [ ] You understand the 6-stage workflow
+- [ ] You know where to find help (`/oac:help`)
+
+**All checked?** 🎉 **You're ready to build with OAC!**
+
+---
+
+## 📚 Additional Resources
+
+### Quick Reference
+
+| Command | Purpose |
+|---------|---------|
+| `/oac:status` | Check installation status |
+| `/oac:help` | View comprehensive help |
+| `/oac:setup --core` | Download context files |
+| `/oac:cleanup` | Clean up old temporary files |
+
+### Documentation
+
+- **This guide**: First-time setup (you are here)
+- **QUICK-START.md**: Usage examples and workflows
+- **INSTALL.md**: Detailed installation guide
+- **README.md**: Complete system overview
+
+### Support
+
+- **Issues**: https://github.com/darrenhinde/OpenAgentsControl/issues
+- **Discussions**: https://github.com/darrenhinde/OpenAgentsControl/discussions
+- **Status Check**: Run `/oac:status` for diagnostic information
+
+---
+
+## 🎉 Welcome to OAC!
+
+You're now ready to build high-quality, context-aware code with OpenAgents Control.
+
+**Remember**:
+- OAC automatically guides you through the 6-stage workflow
+- Approval gates keep you in control
+- Context files ensure consistent, high-quality code
+- Skills and subagents handle the complexity
+
+**Happy coding!** 🚀
+
+---
+
+**Version**: 1.0.0
+**Last Updated**: 2026-02-16
+**Status**: Production Ready
diff --git a/plugins/claude-code/INSTALL.md b/plugins/claude-code/INSTALL.md
new file mode 100644
index 0000000..b2897f6
--- /dev/null
+++ b/plugins/claude-code/INSTALL.md
@@ -0,0 +1,239 @@
+# OAC Plugin - Installation Guide
+
+Complete guide to install and configure the OAC (OpenAgents Control) plugin for Claude Code.
+
+## 🚀 Quick Install
+
+### Method 1: From GitHub (Recommended)
+
+```bash
+# Add the marketplace
+/plugin marketplace add darrenhinde/OpenAgentsControl
+
+# Install the plugin
+/plugin install oac
+```
+
+### Method 2: Local Development
+
+```bash
+# Navigate to the repo
+cd /path/to/OpenAgentsControl
+
+# Start Claude with the plugin
+claude --plugin-dir ./plugins/claude-code
+```
+
+## 📥 Setup Context Files
+
+**IMPORTANT**: After installation, download context files to enable context-aware development.
+
+### Option 1: Download Core Context (Recommended)
+
+```bash
+/oac:setup --core
+```
+
+Downloads essential standards and workflows (~50 files).
+
+### Option 2: Download All Context
+
+```bash
+/oac:setup --all
+```
+
+Downloads all context including examples and guides (~200 files).
+
+### Option 3: Download Specific Category
+
+```bash
+/oac:setup --category=standards
+```
+
+Available categories:
+- `core` - Essential standards and workflows
+- `openagents-repo` - OAC-specific guides and patterns
+- `plugins` - Plugin development guides
+- `skills` - Skill creation and usage
+
+## ✅ Verification
+
+After installation and setup, verify everything works:
+
+### 1. Check Plugin Status
+
+```bash
+/oac:status
+```
+
+You should see:
+- ✅ Plugin version
+- ✅ Context installed
+- ✅ Available subagents (6)
+- ✅ Available skills (9)
+- ✅ Available commands (4)
+
+### 2. View Available Features
+
+```bash
+/oac:help
+```
+
+Shows the complete usage guide with all skills, subagents, and commands.
+
+### 3. Test the Workflow
+
+```bash
+# Start a simple task to test the workflow
+"Add a hello world function"
+```
+
+Claude should automatically invoke the `/using-oac` skill and guide you through the 6-stage workflow.
+
+## 📦 What Gets Installed
+
+When you install the plugin, Claude Code sets up:
+
+```
+~/.claude/plugins/cache/oac/
+├── .claude-plugin/plugin.json # Plugin manifest
+├── agents/ # 6 custom subagents
+│ ├── task-manager.md
+│ ├── context-scout.md
+│ ├── external-scout.md
+│ ├── coder-agent.md
+│ ├── test-engineer.md
+│ └── code-reviewer.md
+├── skills/ # 9 workflow skills
+│ ├── using-oac/SKILL.md
+│ ├── context-discovery/SKILL.md
+│ ├── external-scout/SKILL.md
+│ ├── task-breakdown/SKILL.md
+│ ├── code-execution/SKILL.md
+│ ├── test-generation/SKILL.md
+│ ├── code-review/SKILL.md
+│ ├── context-manager/SKILL.md
+│ └── parallel-execution/SKILL.md
+├── commands/ # 4 user commands
+│ ├── oac-setup.md
+│ ├── oac-help.md
+│ ├── oac-status.md
+│ └── oac-cleanup.md
+├── hooks/ # SessionStart automation
+│ ├── hooks.json
+│ └── session-start.sh
+└── scripts/ # Utility scripts
+ ├── download-context.sh
+ └── verify-context.sh
+```
+
+After running `/oac:setup`, context files are downloaded to your project:
+
+```
+your-project/
+└── .opencode/
+ └── context/
+ ├── core/ # Standards, workflows, patterns
+ ├── openagents-repo/ # OAC-specific guides
+ ├── plugins/ # Plugin development
+ └── skills/ # Skill creation
+```
+
+## 🏗️ Architecture Overview
+
+OAC uses a **flattened delegation hierarchy** optimized for Claude Code:
+
+### Traditional OAC (Nested)
+```
+Main Agent
+ └─> TaskManager
+ └─> CoderAgent
+ └─> ContextScout (❌ Not allowed in Claude Code)
+```
+
+### Claude Code OAC (Flattened)
+```
+Main Agent (orchestrated by /using-oac skill)
+ ├─> task-manager subagent
+ ├─> context-scout subagent
+ ├─> coder-agent subagent
+ ├─> test-engineer subagent
+ └─> code-reviewer subagent
+```
+
+**Key Difference**:
+- Skills guide the main agent's workflow
+- Main agent invokes subagents directly (no nesting)
+- Context is pre-loaded in Stage 3 (no nested ContextScout calls)
+
+## 🔧 Troubleshooting
+
+### Plugin not found
+```bash
+# Check plugin list
+/plugin list
+
+# Verify installation directory
+ls ~/.claude/plugins/cache/oac/
+```
+
+### Context not installed
+```bash
+# Check status
+/oac:status
+
+# If context missing, run setup
+/oac:setup --core
+```
+
+### Skills not working
+```bash
+# Verify skill files exist
+ls ~/.claude/plugins/cache/oac/skills/
+
+# Restart Claude Code
+# Try with verbose logging
+claude --plugin-dir ./plugins/claude-code --verbose
+```
+
+### Subagents not available
+```bash
+# Check status
+/oac:status
+
+# Verify agent files
+ls ~/.claude/plugins/cache/oac/agents/
+
+# Should show 6 .md files
+```
+
+### Download fails
+```bash
+# Try core context first (smaller)
+/oac:setup --core
+
+# Check internet connection
+# Verify GitHub access
+
+# Manual fallback (see /oac:setup output for instructions)
+```
+
+## 🎯 Next Steps
+
+After successful installation:
+
+1. **Read the Quick Start**: See `QUICK-START.md` for usage examples
+2. **Explore the help**: Run `/oac:help` for detailed workflow guide
+3. **Start building**: Let the `/using-oac` skill guide your development
+4. **Review context**: Explore `.opencode/context/` to understand available standards
+
+## 🆘 Need Help?
+
+- **Issues**: https://github.com/darrenhinde/OpenAgentsControl/issues
+- **Discussions**: https://github.com/darrenhinde/OpenAgentsControl/discussions
+- **Status Check**: Run `/oac:status` for diagnostic information
+
+---
+
+**Version**: 1.0.0
+**Last Updated**: 2026-02-16
diff --git a/plugins/claude-code/QUICK-START.md b/plugins/claude-code/QUICK-START.md
new file mode 100644
index 0000000..310ce9b
--- /dev/null
+++ b/plugins/claude-code/QUICK-START.md
@@ -0,0 +1,587 @@
+# OAC Plugin - Quick Start Guide
+
+**Version**: 1.0.0
+**Date**: 2026-02-16
+**Status**: ✅ Production Ready
+
+---
+
+## 🚀 Getting Started (3 Steps)
+
+### 1. Install the Plugin
+
+```bash
+# From GitHub marketplace
+/plugin marketplace add darrenhinde/OpenAgentsControl
+/plugin install oac
+
+# OR for local development
+claude --plugin-dir ./plugins/claude-code
+```
+
+### 2. Download Context Files
+
+```bash
+# Download core context (recommended)
+/oac:setup --core
+
+# OR download everything
+/oac:setup --all
+```
+
+### 3. Verify Installation
+
+```bash
+# Check status
+/oac:status
+
+# View help
+/oac:help
+```
+
+**You're ready!** Start any development task and the `/using-oac` skill will automatically guide you.
+
+---
+
+## 📋 Quick Reference: 9 Skills
+
+### 1. `/using-oac` - Main Workflow Orchestrator
+**Auto-invoked on every task** to ensure context-aware development.
+
+**6-Stage Workflow**:
+1. **Analyze & Discover** - Understand task, find context files
+2. **Plan & Approve** - Present plan, REQUEST APPROVAL
+3. **LoadContext** - Pre-load all context files (internal + external)
+4. **Execute** - Implement (direct or via task breakdown)
+5. **Validate** - Run tests, STOP on failure
+6. **Complete** - Update docs, summarize
+
+**When to use**: Automatically invoked (you don't need to call it manually).
+
+---
+
+### 2. `/context-discovery` - Find Relevant Context
+Guides the main agent to use the `context-scout` subagent for discovering standards and patterns.
+
+**Usage**:
+```
+/context-discovery authentication feature
+```
+
+**What it does**:
+- Searches `.opencode/context/` for relevant files
+- Prioritizes by relevance (Critical → High → Medium)
+- Returns list of files to load
+
+**Example output**:
+```
+Critical:
+- .opencode/context/core/standards/security.md
+- .opencode/context/core/patterns/authentication.md
+
+High:
+- .opencode/context/core/standards/typescript.md
+```
+
+---
+
+### 3. `/external-scout` - Fetch External Library Docs
+Guides the main agent to use the `external-scout` subagent for fetching current API documentation.
+
+**Usage**:
+```
+/external-scout drizzle schemas
+/external-scout react hooks
+/external-scout express middleware
+```
+
+**What it does**:
+- Fetches current documentation from Context7 and other sources
+- Caches results in `.tmp/external-context/` (fresh for 7 days)
+- Returns file paths to load
+- Ensures you're using current API patterns (not outdated training data)
+
+**Example output**:
+```json
+{
+ "status": "success",
+ "package": "drizzle",
+ "topic": "schemas",
+ "files": [".tmp/external-context/drizzle/schemas.md"],
+ "message": "Documentation cached. Load file to access current API patterns."
+}
+```
+
+**Why it matters**: Training data is outdated. External libraries change their APIs, deprecate features, and introduce new patterns. ExternalScout ensures you're implementing with current, correct patterns.
+
+---
+
+### 4. `/task-breakdown` - Decompose Complex Features
+Guides the main agent to use the `task-manager` subagent for breaking down complex tasks.
+
+**Usage**:
+```
+/task-breakdown user authentication system
+```
+
+**What it does**:
+- Breaks feature into atomic subtasks (1-2 hours each)
+- Creates dependency graph
+- Generates subtask JSON files in `.tmp/tasks/`
+- Enables parallel execution where possible
+
+**Example output**:
+```
+Subtasks created:
+1. JWT service implementation
+2. Auth middleware (depends on #1)
+3. Login endpoint (depends on #1, #2)
+4. Refresh token logic (depends on #1)
+5. Integration tests (depends on all)
+```
+
+---
+
+### 5. `/code-execution` - Implement Features
+Guides the main agent to use the `coder-agent` subagent for implementing code.
+
+**Usage**:
+```
+/code-execution implement JWT service
+```
+
+**What it does**:
+- Implements features following loaded context
+- Applies coding standards and patterns
+- Runs self-review before completion
+- Updates subtask status if part of task breakdown
+
+**Self-Review Checks**:
+- ✅ Type & import validation
+- ✅ Anti-pattern scan (console.log, TODO, hardcoded secrets)
+- ✅ Acceptance criteria verification
+- ✅ External library verification
+
+---
+
+### 6. `/test-generation` - Create Comprehensive Tests
+Guides the main agent to use the `test-engineer` subagent for generating tests.
+
+**Usage**:
+```
+/test-generation authentication service
+```
+
+**What it does**:
+- Generates tests following TDD principles
+- Covers happy paths, edge cases, error handling
+- Follows test standards from context
+- Ensures test isolation and clarity
+
+**Test Coverage**:
+- Unit tests for individual functions
+- Integration tests for workflows
+- Edge cases and error scenarios
+- Security validation tests
+
+---
+
+### 7. `/code-review` - Review Code Quality
+Guides the main agent to use the `code-reviewer` subagent for reviewing code.
+
+**Usage**:
+```
+/code-review src/auth/
+```
+
+**What it does**:
+- Reviews code for quality and standards compliance
+- Checks security patterns
+- Identifies anti-patterns
+- Suggests improvements
+
+**Review Areas**:
+- Code quality and readability
+- Security vulnerabilities
+- Performance issues
+- Standards compliance
+- Test coverage
+
+---
+
+### 8. `/context-manager` - Manage Context & Configuration
+Manage context files, configuration, and project-specific settings.
+
+**Usage**:
+```
+/context-manager
+```
+
+**What it does**:
+- Set up new projects with OAC context files
+- Configure context sources and download preferences
+- Integrate external task systems (SpecKit, Linear, Jira, custom)
+- Manage personal context files and templates
+- Troubleshoot context loading or configuration issues
+- Update or refresh downloaded context files
+
+**Use when**:
+- Setting up a new project
+- Configuring .oac file
+- Integrating with external task management
+- Managing personal templates and preferences
+
+---
+
+### 9. `/parallel-execution` - Execute Tasks in Parallel
+Execute multiple independent tasks simultaneously to reduce implementation time.
+
+**Usage**:
+```
+# Automatically used when task-manager marks tasks with parallel:true
+# Or invoke manually for independent work
+```
+
+**What it does**:
+- Execute multiple independent tasks simultaneously
+- Dramatically reduce implementation time for multi-component features
+- Coordinate parallel work streams (frontend + backend + tests)
+- Monitor progress and handle failures gracefully
+
+**Use when**:
+- Multiple independent tasks with no dependencies
+- Multi-component features (frontend + backend + tests)
+- Time-sensitive delivery
+- Batch operations (converting files, running tests)
+
+**Time savings**: 50-80% reduction for multi-component features
+
+---
+
+## 🎮 Quick Reference: 4 Commands
+
+### 1. `/oac:setup` - Download Context Files
+
+**Usage**:
+```bash
+/oac:setup # Interactive mode
+/oac:setup --core # Core context only (~50 files)
+/oac:setup --all # All context (~200 files)
+/oac:setup --category=standards # Specific category
+```
+
+**What it downloads**:
+- Coding standards and conventions
+- Architecture patterns
+- Security guidelines
+- Workflow guides
+- Domain-specific documentation
+
+**Output**: Creates `.opencode/context/` and `.context-manifest.json`
+
+---
+
+### 2. `/oac:help` - Show Usage Guide
+
+**Usage**:
+```bash
+/oac:help # General help
+/oac:help context-discovery # Skill-specific help
+```
+
+**What it shows**:
+- 6-stage workflow overview
+- Available subagents and when to use them
+- Available skills and usage examples
+- Available commands
+- Quick start examples
+- Troubleshooting guide
+
+---
+
+### 3. `/oac:status` - Check Installation Status
+
+**Usage**:
+```bash
+/oac:status
+```
+
+**What it shows**:
+- Plugin version
+- Context installation status
+- Active sessions count
+- Available subagents (6)
+- Available skills (9)
+- Available commands (4)
+- Recommendations for cleanup or setup
+
+---
+
+### 4. `/oac:cleanup` - Clean Up Temporary Files
+
+**Usage**:
+```bash
+/oac:cleanup # Interactive mode
+/oac:cleanup --force # Skip confirmation
+/oac:cleanup --session-days=3 # Clean sessions older than 3 days
+/oac:cleanup --task-days=14 # Clean tasks older than 14 days
+/oac:cleanup --external-days=3 # Clean external context older than 3 days
+```
+
+**What it cleans**:
+- Old session files from `.tmp/sessions/`
+- Completed task files from `.tmp/tasks/`
+- Cached external documentation from `.tmp/external-context/`
+
+**Default retention**:
+- Sessions: 7 days
+- Completed tasks: 30 days
+- External context: 7 days
+
+**Example**:
+```bash
+# Clean with defaults
+/oac:cleanup
+
+# Aggressive cleanup
+/oac:cleanup --session-days=3 --task-days=14 --external-days=3 --force
+```
+
+---
+
+## 💡 Example Workflows
+
+### Example 1: Simple Feature (Direct Implementation)
+
+**Task**: "Add a login endpoint"
+
+**Workflow**:
+```
+1. Analyze & Discover
+ - Understand: Need POST /api/login endpoint
+ - Invoke /context-discovery → finds API standards, security patterns
+
+2. Plan & Approve
+ - Plan: Create endpoint in src/api/auth.ts
+ - Files: auth.ts, auth.test.ts, api-docs.md
+ - REQUEST APPROVAL ← User approves
+
+3. LoadContext
+ - Read API standards
+ - Read security patterns
+ - Read TypeScript conventions
+ - (If using external libs) Invoke /external-scout for current API docs
+
+4. Execute
+ - Implement endpoint directly (simple task)
+ - Follow loaded standards
+
+5. Validate
+ - Run tests
+ - Verify acceptance criteria
+
+6. Complete
+ - Update API docs
+ - Summarize changes
+```
+
+**Time**: ~15-30 minutes
+
+---
+
+### Example 2: Complex Feature (Task Breakdown)
+
+**Task**: "Build a complete authentication system"
+
+**Workflow**:
+```
+1. Analyze & Discover
+ - Understand: Full auth system (JWT, refresh, middleware, endpoints)
+ - Invoke /context-discovery → finds security, API, TypeScript standards
+
+2. Plan & Approve
+ - Plan: Multi-component system, suggest task breakdown
+ - Complexity: 4+ files, >30 min
+ - REQUEST APPROVAL ← User approves
+
+3. LoadContext
+ - Read security patterns
+ - Read API standards
+ - Read TypeScript conventions
+ - Read test standards
+ - Invoke /external-scout for any external libraries (e.g., JWT library, database ORM)
+
+4. Execute
+ - Invoke /task-breakdown → creates subtasks:
+ * Subtask 1: JWT service (core logic)
+ * Subtask 2: Auth middleware (depends on #1)
+ * Subtask 3: Login endpoint (depends on #1, #2)
+ * Subtask 4: Refresh endpoint (depends on #1)
+ * Subtask 5: Integration tests (depends on all)
+
+ - For each subtask:
+ * Invoke /code-execution
+ * Implement following loaded context
+ * Run self-review
+ * Mark subtask complete
+
+5. Validate
+ - Run all integration tests
+ - Verify system works end-to-end
+ - STOP if any test fails
+
+6. Complete
+ - Update API documentation
+ - Update security documentation
+ - Summarize all changes
+```
+
+**Time**: ~2-4 hours (broken into 1-2 hour subtasks)
+
+---
+
+### Example 3: Using Subagents Directly
+
+**Task**: "Review and test the authentication system"
+
+**Workflow**:
+```
+# Step 1: Discover context
+Use the context-scout subagent to find:
+- Security review checklists
+- Test standards
+- Code quality guidelines
+
+# Step 2: Review code
+Use the code-reviewer subagent to review:
+- src/auth/ directory
+- Check security patterns
+- Identify issues
+
+# Step 3: Generate tests
+Use the test-engineer subagent to create:
+- Unit tests for JWT service
+- Integration tests for auth flow
+- Security validation tests
+
+# Step 4: Verify
+Run tests and confirm all pass
+```
+
+---
+
+## 🏗️ Architecture: Flattened Delegation
+
+OAC for Claude Code uses a **flattened hierarchy** (no nested subagent calls):
+
+### ❌ Traditional OAC (Not Allowed in Claude Code)
+```
+Main Agent
+ └─> TaskManager
+ └─> CoderAgent
+ └─> ContextScout (nested - not allowed)
+```
+
+### ✅ Claude Code OAC (Flattened)
+```
+Main Agent (orchestrated by /using-oac skill)
+ ├─> task-manager subagent
+ ├─> context-scout subagent
+ ├─> coder-agent subagent
+ ├─> test-engineer subagent
+ └─> code-reviewer subagent
+```
+
+**How it works**:
+1. **Skills** guide the main agent's workflow (when to invoke which subagent)
+2. **Main agent** invokes subagents directly (no nesting)
+3. **Context** is pre-loaded in Stage 3 (no nested ContextScout calls during execution)
+4. **Subagents** return results to main agent for orchestration
+
+---
+
+## 🆘 Troubleshooting
+
+### "Context files not found"
+```bash
+# Download context
+/oac:setup --core
+
+# Verify installation
+/oac:status
+```
+
+### "Subagent not available"
+```bash
+# Check status
+/oac:status
+
+# Should show 6 subagents
+# If missing, reinstall plugin
+```
+
+### "Approval not requested"
+```bash
+# This is a bug - OAC should ALWAYS request approval in Stage 2
+# Please report at: https://github.com/darrenhinde/OpenAgentsControl/issues
+```
+
+### "Nested subagent call error"
+```bash
+# Claude Code doesn't support nested calls
+# Use skills to orchestrate, not subagents calling subagents
+# The /using-oac skill handles this automatically
+```
+
+### "Tests failing in Stage 5"
+```bash
+# This is expected behavior - OAC stops on test failure
+# Fix the failing tests before proceeding
+# Re-run validation after fixes
+```
+
+---
+
+## 🎯 Best Practices
+
+### 1. Context First, Code Second
+Always let the workflow discover and load context before implementing. This ensures your code follows project standards.
+
+### 2. Approve Before Execution
+Review the plan in Stage 2 carefully. Once approved, OAC will execute automatically.
+
+### 3. Break Down Complex Tasks
+For features with 4+ files or >30 min work, use task breakdown for better tracking and parallel execution.
+
+### 4. Trust the Self-Review
+CoderAgent runs comprehensive checks before completion. If it passes, the code is ready.
+
+### 5. Use Status Commands
+Run `/oac:status` regularly to check installation and active sessions.
+
+---
+
+## 📚 Learn More
+
+- **Installation**: See `INSTALL.md` for detailed setup
+- **Full Help**: Run `/oac:help` for comprehensive guide
+- **Architecture**: See `README.md` for system overview
+- **Context Files**: Explore `.opencode/context/` after running `/oac:setup`
+
+---
+
+## 🔗 Quick Links
+
+| Resource | Command/Link |
+|----------|--------------|
+| Check Status | `/oac:status` |
+| Get Help | `/oac:help` |
+| Download Context | `/oac:setup --core` |
+| GitHub Issues | https://github.com/darrenhinde/OpenAgentsControl/issues |
+| Discussions | https://github.com/darrenhinde/OpenAgentsControl/discussions |
+
+---
+
+**Ready to build!** 🎉
+
+Start any development task and let the `/using-oac` skill guide you through context-aware development.
diff --git a/plugins/claude-code/README.md b/plugins/claude-code/README.md
new file mode 100644
index 0000000..7f77e8a
--- /dev/null
+++ b/plugins/claude-code/README.md
@@ -0,0 +1,495 @@
+# OAC - Claude Code Plugin
+
+OpenAgents Control (OAC) - Multi-agent orchestration and automation for Claude Code.
+
+## 🎯 Overview
+
+OpenAgents Control brings powerful multi-agent capabilities to Claude Code through a **skills + subagents architecture**:
+
+- **9 Skills** orchestrate workflows and guide the main agent through multi-stage processes
+- **6 Subagents** execute specialized tasks (context discovery, task breakdown, code implementation, testing, review)
+- **4 Commands** provide setup, status, help, and cleanup functionality
+- **Flat delegation hierarchy** - only the main agent can invoke subagents (no nested calls)
+- **Context pre-loading** - all standards and patterns loaded upfront to prevent nested discovery
+- **6-stage workflow** - ensures context-aware, high-quality code delivery with approval gates
+
+### Key Features
+
+- **Intelligent Context Discovery** - Smart discovery of coding standards, security patterns, and conventions
+- **Task Management** - Break down complex features into atomic, verifiable subtasks
+- **Code Execution** - Context-aware implementation following project standards
+- **Test Engineering** - TDD-driven test creation and validation
+- **Code Review** - Automated code quality and security analysis
+
+## 📦 Installation
+
+### Option 1: From Marketplace (Recommended)
+
+```bash
+# Add the OpenAgents Control marketplace
+/plugin marketplace add darrenhinde/OpenAgentsControl
+
+# Install the plugin
+/plugin install oac
+```
+
+### Option 2: Local Development
+
+```bash
+# Clone the repo
+git clone https://github.com/darrenhinde/OpenAgentsControl.git
+cd OpenAgentsControl
+
+# Load plugin locally
+claude --plugin-dir ./plugins/claude-code
+```
+
+## 🚀 Quick Start
+
+After installation, download context files and start using OAC:
+
+```bash
+# Download context files from GitHub
+/oac:setup
+
+# Verify installation
+/oac:status
+
+# Get help and usage guide
+/oac:help
+```
+
+The **using-oac** skill is automatically invoked when you start a development task, guiding you through the 6-stage workflow.
+
+## 📚 Available Skills
+
+Skills guide the main agent through specific workflows:
+
+### using-oac
+Main workflow orchestrator implementing the 6-stage process (Analyze → Plan → LoadContext → Execute → Validate → Complete).
+
+**Auto-invoked**: When you start a development task.
+
+### context-discovery
+Guide for discovering and loading relevant context files (coding standards, security patterns, conventions).
+
+**Usage**: `/context-discovery authentication feature`
+
+**Invokes**: `context-scout` subagent via `context: fork`
+
+### external-scout
+Guide for fetching external library and framework documentation from Context7 and other sources.
+
+**Usage**: `/external-scout drizzle schemas`
+
+**Invokes**: `external-scout` subagent via `context: fork`
+
+### task-breakdown
+Guide for breaking down complex features into atomic subtasks with dependency tracking.
+
+**Usage**: `/task-breakdown user authentication system`
+
+**Invokes**: `task-manager` subagent via `context: fork`
+
+### code-execution
+Guide for executing coding tasks with full context awareness and self-review.
+
+**Usage**: `/code-execution implement JWT service`
+
+**Invokes**: `coder-agent` subagent via `context: fork`
+
+### test-generation
+Guide for generating comprehensive tests using TDD principles.
+
+**Usage**: `/test-generation authentication service`
+
+**Invokes**: `test-engineer` subagent via `context: fork`
+
+### code-review
+Guide for performing thorough code reviews with security and quality analysis.
+
+**Usage**: `/code-review src/auth/`
+
+**Invokes**: `code-reviewer` subagent via `context: fork`
+
+### context-manager
+Manage context files, configuration, and project-specific settings. Set up projects, configure context sources, and integrate external task systems.
+
+**Usage**: `/context-manager`
+
+**Use when**: Setting up projects, configuring context sources, managing personal task systems
+
+### parallel-execution
+Execute multiple independent tasks in parallel to dramatically reduce implementation time for multi-component features.
+
+**Usage**: Automatically used when task-manager marks tasks with `parallel: true`
+
+**Use when**: Multiple independent tasks with no dependencies, need to speed up multi-component features
+
+## 🤖 Available Subagents
+
+Subagents execute specialized tasks in isolated contexts:
+
+### task-manager
+Break down complex features into atomic, verifiable subtasks with dependency tracking and JSON-based progress management.
+
+**Tools**: Read, Write, Glob, Grep
+**Model**: sonnet
+
+### context-scout
+Discover relevant context files, standards, and patterns using navigation-driven discovery.
+
+**Tools**: Read, Glob, Grep
+**Model**: haiku
+
+### external-scout
+Fetch external library and framework documentation from Context7 API and other sources, with local caching.
+
+**Tools**: Read, Write, Bash
+**Model**: haiku
+
+### coder-agent
+Execute coding subtasks with full context awareness, self-review, and quality validation.
+
+**Tools**: Read, Write, Edit, Glob, Grep
+**Model**: sonnet
+
+### test-engineer
+Generate comprehensive tests using TDD principles with coverage analysis and validation.
+
+**Tools**: Read, Write, Edit, Bash, Glob, Grep
+**Model**: sonnet
+
+### code-reviewer
+Perform thorough code review with security analysis, quality checks, and actionable feedback.
+
+**Tools**: Read, Bash, Glob, Grep
+**Model**: sonnet
+
+## 📝 Available Commands
+
+User-invocable commands for setup and status:
+
+### /oac:setup
+Download context files from the OpenAgents Control GitHub repository.
+
+**Usage**: `/oac:setup [--core|--all|--category=]`
+
+**Options**:
+- `--core` - Download only core context files (standards, workflows, patterns)
+- `--all` - Download all context files including examples and guides
+- `--category=` - Download specific category (e.g., `--category=standards`)
+
+### /oac:help
+Show usage guide for OAC workflow, skills, subagents, and commands.
+
+**Usage**:
+- `/oac:help` - Show general help
+- `/oac:help ` - Show help for specific skill
+
+### /oac:status
+Show plugin status, installed context version, and available components.
+
+**Usage**: `/oac:status`
+
+**Shows**:
+- Plugin version
+- Installed context version
+- Available subagents and skills
+- Context file count
+
+### /oac:cleanup
+Clean up old temporary files from `.tmp` directory.
+
+**Usage**: `/oac:cleanup [--force] [--session-days=N] [--task-days=N] [--external-days=N]`
+
+**Options**:
+- `--force` - Skip confirmation and delete immediately
+- `--session-days=N` - Clean sessions older than N days (default: 7)
+- `--task-days=N` - Clean completed tasks older than N days (default: 30)
+- `--external-days=N` - Clean external context older than N days (default: 7)
+
+**Cleans**:
+- Old session files from `.tmp/sessions/`
+- Completed task files from `.tmp/tasks/`
+- Cached external documentation from `.tmp/external-context/`
+
+**Example**:
+```bash
+# Clean with defaults
+/oac:cleanup
+
+# Clean aggressively (3 days for sessions)
+/oac:cleanup --session-days=3 --force
+```
+
+## 🔄 How It Works
+
+### 6-Stage Workflow
+
+OAC implements a structured workflow for every development task:
+
+#### Stage 1: Analyze & Discover
+- Understand requirements and scope
+- Invoke `/context-discovery` to find relevant context files
+- Identify project standards, patterns, and conventions
+
+#### Stage 2: Plan & Approve
+- Present implementation plan
+- **REQUEST APPROVAL** before proceeding
+- Confirm approach with user
+
+#### Stage 3: LoadContext
+- Read all discovered context files
+- Load coding standards, security patterns, naming conventions
+- Pre-load context for execution stage (prevents nested discovery)
+
+#### Stage 4: Execute
+- **Simple tasks** (1-3 files): Direct implementation
+- **Complex tasks** (4+ files): Invoke `/task-breakdown` to decompose into subtasks
+- Follow loaded standards and patterns
+
+#### Stage 5: Validate
+- Run tests and validation
+- **STOP on failure** - fix before proceeding
+- Verify acceptance criteria met
+
+#### Stage 6: Complete
+- Update documentation
+- Summarize changes
+- Return results
+
+### Architecture: Skills Invoke Subagents via `context: fork`
+
+**OAC Pattern** (nested - NOT supported in Claude Code):
+```
+Main Agent → TaskManager → CoderAgent → ContextScout
+```
+
+**Claude Code Pattern** (flat - CORRECT):
+```
+Main Agent → /context-discovery skill → context-scout subagent
+Main Agent → /task-breakdown skill → task-manager subagent
+Main Agent → /code-execution skill → coder-agent subagent
+```
+
+**Key Principle**: Only the main agent can invoke subagents. Skills guide the orchestration, subagents execute specialized tasks in isolated contexts (`context: fork`).
+
+### Context Pre-Loading
+
+**Why**: Prevents nested ContextScout calls during execution.
+
+**How**: Stage 3 loads ALL context upfront, so execution stages (4-6) have everything they need.
+
+**Example**:
+```
+Stage 1: Discover context files → [standards.md, security.md, patterns.md]
+Stage 3: Load all files → Read standards.md, Read security.md, Read patterns.md
+Stage 4: Execute with loaded context → No nested discovery needed
+```
+
+### Approval Gates
+
+**Critical checkpoints**:
+- **Stage 2 → Stage 3**: User must approve the plan
+- **Stage 5 → Stage 6**: Validation must pass
+
+**Never skip approval** - it prevents wasted work and ensures alignment.
+
+## 🔧 Configuration
+
+The plugin uses context files from the main OpenAgents Control repository.
+
+### Context Structure
+
+```
+plugins/claude-code/
+├── .claude-plugin/
+│ └── plugin.json # Plugin metadata
+├── agents/ # Custom subagents (6 files)
+│ ├── task-manager.md
+│ ├── context-scout.md
+│ ├── external-scout.md
+│ ├── coder-agent.md
+│ ├── test-engineer.md
+│ └── code-reviewer.md
+├── skills/ # Workflow skills (9 files)
+│ ├── using-oac/SKILL.md
+│ ├── context-discovery/SKILL.md
+│ ├── external-scout/SKILL.md
+│ ├── task-breakdown/SKILL.md
+│ ├── code-execution/SKILL.md
+│ ├── test-generation/SKILL.md
+│ ├── code-review/SKILL.md
+│ ├── context-manager/SKILL.md
+│ └── parallel-execution/SKILL.md
+├── commands/ # User commands (4 files)
+│ ├── oac-setup.md
+│ ├── oac-help.md
+│ ├── oac-status.md
+│ └── oac-cleanup.md
+├── hooks/ # Event-driven automation
+│ ├── hooks.json
+│ └── session-start.sh
+├── scripts/ # Utility scripts
+│ ├── download-context.sh
+│ └── verify-context.sh
+└── .context-manifest.json # Downloaded context tracking
+```
+
+### Context Files
+
+Context files are downloaded from the main repository via `/oac:setup`:
+
+```
+.opencode/context/
+├── core/ # Core standards and workflows
+│ ├── standards/
+│ ├── workflows/
+│ └── patterns/
+├── openagents-repo/ # OAC-specific guides
+│ ├── guides/
+│ ├── standards/
+│ └── concepts/
+└── navigation.md # Context discovery navigation
+```
+
+## 🛠️ Development
+
+### Adding New Skills
+
+1. Create skill directory:
+ ```bash
+ mkdir -p plugins/claude-code/skills/my-skill
+ ```
+
+2. Create `SKILL.md` with frontmatter:
+ ```markdown
+ ---
+ name: my-skill
+ description: What this skill does
+ context: fork
+ agent: my-subagent
+ ---
+
+ # My Skill
+
+ Instructions for the main agent...
+ ```
+
+3. Test locally:
+ ```bash
+ claude --plugin-dir ./plugins/claude-code
+ /my-skill
+ ```
+
+### Adding New Subagents
+
+1. Create subagent file:
+ ```bash
+ touch plugins/claude-code/agents/my-subagent.md
+ ```
+
+2. Add frontmatter:
+ ```markdown
+ ---
+ name: my-subagent
+ description: What this subagent does
+ tools: Read, Write, Glob, Grep
+ model: sonnet
+ ---
+
+ # MySubagent
+
+ Instructions for the subagent...
+ ```
+
+3. Create skill to invoke it:
+ ```markdown
+ ---
+ name: my-workflow
+ description: Workflow description
+ context: fork
+ agent: my-subagent
+ ---
+ ```
+
+### Adding Hooks
+
+Create `hooks/hooks.json`:
+
+```json
+{
+ "hooks": {
+ "SessionStart": [{
+ "type": "command",
+ "command": "${CLAUDE_PLUGIN_ROOT}/hooks/session-start.sh",
+ "timeout": 5
+ }],
+ "PostToolUse": [{
+ "matcher": "Write|Edit",
+ "hooks": [{
+ "type": "command",
+ "command": "${CLAUDE_PLUGIN_ROOT}/scripts/format.sh",
+ "timeout": 30
+ }]
+ }]
+ }
+}
+```
+
+## 🔗 Related Projects
+
+- **OpenAgents Control** - Main repository (OpenCode native)
+- **OAC CLI** - Command-line tool for multi-IDE management (coming soon)
+
+## 📖 Documentation
+
+- [Installation Guide](INSTALL.md)
+- [Quick Start Guide](QUICK-START.md)
+- [Main Documentation](../.opencode/docs/)
+- [Context System](../docs/context-system/)
+- [Planning Documents](../docs/planning/)
+
+## 🤝 Contributing
+
+Contributions welcome! See the main [OpenAgents Control repository](https://github.com/darrenhinde/OpenAgentsControl) for contribution guidelines.
+
+## 📄 License
+
+MIT License - see [LICENSE](../LICENSE) for details.
+
+## 🆘 Support
+
+- **Issues**: [GitHub Issues](https://github.com/darrenhinde/OpenAgentsControl/issues)
+- **Discussions**: [GitHub Discussions](https://github.com/darrenhinde/OpenAgentsControl/discussions)
+
+## 🗺️ Roadmap
+
+### Phase 1: Foundation ✅ COMPLETE
+- ✅ Plugin structure
+- ✅ 6 custom subagents (task-manager, context-scout, external-scout, coder-agent, test-engineer, code-reviewer)
+- ✅ 9 workflow skills (using-oac, context-discovery, external-scout, task-breakdown, code-execution, test-generation, code-review, context-manager, parallel-execution)
+- ✅ 4 user commands (/oac:setup, /oac:help, /oac:status, /oac:cleanup)
+- ✅ SessionStart hook for auto-loading using-oac skill
+- ✅ Context download and verification scripts
+- ✅ Flat delegation hierarchy (skills invoke subagents via context: fork)
+
+### Phase 2: Advanced Features ✅ COMPLETE
+- ✅ External library documentation fetching (ExternalScout subagent + skill)
+- ✅ .tmp cleanup automation (/oac:cleanup command)
+- ✅ .oac configuration file support (context-manager skill)
+- ✅ Context management and personal task systems (context-manager skill)
+- ✅ Parallel subtask execution tracking (parallel-execution skill)
+- ⬜ MCP server integration (future)
+
+### Phase 3: JSON Config System
+- ⬜ Auto-generation from JSON config
+- ⬜ Type-safe configuration
+- ⬜ Multi-IDE conversion
+
+---
+
+**Version**: 1.0.0
+**Last Updated**: 2026-02-16
+**Status**: Production Ready
diff --git a/plugins/claude-code/agents/code-reviewer.md b/plugins/claude-code/agents/code-reviewer.md
new file mode 100644
index 0000000..f101338
--- /dev/null
+++ b/plugins/claude-code/agents/code-reviewer.md
@@ -0,0 +1,254 @@
+---
+name: code-reviewer
+description: Reviews code for security, correctness, and quality against project standards
+tools: Read, Glob, Grep
+model: sonnet
+---
+
+# CodeReviewer
+
+> **Mission**: Perform thorough code reviews for correctness, security, and quality — grounded in project standards.
+
+
+ Context files (code quality standards, security patterns, naming conventions) are pre-loaded by the main agent. Use them as your review criteria.
+
+
+ Read-only agent. NEVER use write, edit, or bash. Provide review notes and suggested diffs — do NOT apply changes.
+
+
+ Security vulnerabilities are ALWAYS the highest priority finding. Flag them first, with severity ratings. Never bury security issues in style feedback.
+
+
+ Start with: "Reviewing..., what would you devs do if I didn't check up on you?" Then structured findings by severity.
+
+ Code quality gate within the development pipeline
+ Code review — correctness, security, style, performance, maintainability
+ Review code against project standards, flag issues by severity, suggest fixes without applying them
+ Read-only. No code modifications. Suggested diffs only.
+
+ - @context_preloaded: Use pre-loaded standards from main agent
+ - @read_only: Never modify code — suggest only
+ - @security_priority: Security findings first, always
+ - @output_format: Structured output with severity ratings
+
+
+ - Apply project standards to code analysis
+ - Analyze code for security vulnerabilities
+ - Check correctness and logic
+ - Verify style and naming conventions
+
+
+ - Performance considerations
+ - Maintainability assessment
+ - Test coverage gaps
+ - Documentation completeness
+
+ Tier 1 always overrides Tier 2/3. Security findings always surface first regardless of other issues found.
+---
+
+## Review Workflow
+
+### Step 1: Understand Review Scope
+
+Read the review request to identify:
+- **Files to review** — specific paths or patterns
+- **Review focus** — security, correctness, style, or comprehensive
+- **Context provided** — standards, patterns, conventions already loaded by main agent
+
+### Step 2: Load Target Files
+
+Use `Read`, `Glob`, and `Grep` to:
+- Read all files in review scope
+- Search for patterns (security anti-patterns, missing error handling, etc.)
+- Understand code structure and dependencies
+
+### Step 3: Security Scan (HIGHEST PRIORITY)
+
+Check for security vulnerabilities:
+
+**Authentication & Authorization**:
+- Missing authentication checks
+- Insufficient authorization validation
+- Hardcoded credentials or API keys
+- Insecure session management
+
+**Input Validation**:
+- SQL injection risks (unparameterized queries)
+- XSS vulnerabilities (unescaped user input)
+- Path traversal risks (unsanitized file paths)
+- Command injection (shell execution with user input)
+
+**Data Protection**:
+- Sensitive data in logs
+- Unencrypted sensitive data storage
+- Missing HTTPS enforcement
+- Exposed secrets in environment variables
+
+**Error Handling**:
+- Information leakage in error messages
+- Missing error handling exposing stack traces
+- Unhandled promise rejections
+
+### Step 4: Correctness Review
+
+Verify logic and implementation:
+
+**Type Safety**:
+- Missing type annotations where required
+- Type mismatches between function signatures and usage
+- Unsafe type assertions (`as any`)
+
+**Error Handling**:
+- Async functions without try/catch or .catch()
+- Missing null/undefined checks
+- Unhandled edge cases
+
+**Logic Issues**:
+- Off-by-one errors
+- Race conditions
+- Infinite loops or recursion without base case
+- Incorrect algorithm implementation
+
+**Import/Export**:
+- Missing imports
+- Circular dependencies
+- Unused imports
+
+### Step 5: Style & Convention Review
+
+Check against project standards (pre-loaded by main agent):
+
+**Naming Conventions**:
+- Variable/function/class naming matches project style
+- Consistent casing (camelCase, PascalCase, etc.)
+- Descriptive names (no single-letter variables except loops)
+
+**Code Organization**:
+- Functions are single-purpose and modular
+- Appropriate use of comments (why, not what)
+- Consistent formatting and indentation
+
+**Best Practices**:
+- DRY principle (no code duplication)
+- SOLID principles for classes
+- Functional programming patterns where appropriate
+
+### Step 6: Performance & Maintainability
+
+Assess code quality:
+
+**Performance**:
+- Inefficient algorithms (O(n²) where O(n) possible)
+- Unnecessary re-renders or re-computations
+- Missing memoization where beneficial
+- Blocking operations in async contexts
+
+**Maintainability**:
+- Overly complex functions (high cyclomatic complexity)
+- Magic numbers without constants
+- Missing documentation for non-obvious logic
+- Test coverage gaps
+
+### Step 7: Structure Findings by Severity
+
+Organize all findings into severity levels:
+
+**🔴 CRITICAL** (Security vulnerabilities, data loss risks):
+- Must fix before merge
+- Blocks deployment
+- Example: SQL injection, exposed credentials
+
+**🟠 HIGH** (Correctness issues, logic errors):
+- Should fix before merge
+- May cause bugs or failures
+- Example: Missing error handling, type mismatches
+
+**🟡 MEDIUM** (Style violations, maintainability issues):
+- Fix in this PR or follow-up
+- Impacts code quality
+- Example: Code duplication, poor naming
+
+**🟢 LOW** (Suggestions, optimizations):
+- Nice to have
+- Doesn't block merge
+- Example: Performance optimizations, documentation improvements
+
+### Step 8: Return Review Report
+
+Format findings as structured output:
+
+```markdown
+## Code Review: [File/Feature Name]
+
+**Reviewed by**: CodeReviewer
+**Review Date**: [Date]
+**Files Reviewed**: [List of files]
+
+---
+
+### 🔴 CRITICAL Issues (Must Fix)
+
+1. **[Issue Title]** — `[file:line]`
+ - **Problem**: [What's wrong]
+ - **Risk**: [Security/data impact]
+ - **Fix**: [Suggested solution]
+ - **Diff**:
+ ```diff
+ - old code
+ + new code
+ ```
+
+---
+
+### 🟠 HIGH Priority Issues (Should Fix)
+
+[Same format as Critical]
+
+---
+
+### 🟡 MEDIUM Priority Issues (Consider Fixing)
+
+[Same format]
+
+---
+
+### 🟢 LOW Priority Suggestions
+
+[Same format]
+
+---
+
+### ✅ Positive Observations
+
+- [What was done well]
+- [Good patterns to highlight]
+
+---
+
+### Summary
+
+- **Total Issues**: [Count by severity]
+- **Blocking Issues**: [Critical + High count]
+- **Recommendation**: APPROVE | REQUEST CHANGES | COMMENT
+```
+
+---
+
+## What NOT to Do
+
+- ❌ **Don't modify code** — suggest diffs only, never apply changes
+- ❌ **Don't bury security issues** — they always surface first regardless of severity mix
+- ❌ **Don't review without standards** — if context is missing, request it from main agent
+- ❌ **Don't flag style issues as critical** — match severity to actual impact
+- ❌ **Don't skip error handling checks** — missing error handling is a correctness issue
+- ❌ **Don't provide vague feedback** — every finding includes a suggested fix
+
+---
+
+## Principles
+
+ Standards are pre-loaded by main agent — use them as review criteria
+ Security findings always surface first — they have the highest impact
+ Suggest, never apply — the developer owns the fix
+ Flag severity matches actual impact, not personal preference
+ Every finding includes a suggested fix — not just "this is wrong"
diff --git a/plugins/claude-code/agents/coder-agent.md b/plugins/claude-code/agents/coder-agent.md
new file mode 100644
index 0000000..576965e
--- /dev/null
+++ b/plugins/claude-code/agents/coder-agent.md
@@ -0,0 +1,192 @@
+---
+name: CoderAgent
+description: Execute coding subtasks with self-review and quality validation
+tools: Read, Write, Edit, Glob, Grep
+model: sonnet
+---
+
+# CoderAgent
+
+> **Mission**: Execute coding subtasks precisely, one at a time, with full context awareness and self-review before handoff.
+
+## Core Rules
+
+
+ Context files are pre-loaded by the main agent. Read all context_files from subtask JSON before implementing.
+
+
+
+ NEVER signal completion without running the Self-Review Loop (Step 6). Every deliverable must pass type validation, import verification, anti-pattern scan, and acceptance criteria check.
+
+
+
+ Execute subtasks in the defined sequence. Do not skip or reorder. Complete one fully before starting the next.
+
+
+Subtask execution engine within the OpenAgents task management pipeline
+Software implementation — coding, file creation, integration
+Implement atomic subtasks from JSON definitions, following project standards from pre-loaded context
+Limited bash access for task status updates only. Sequential execution. Self-review mandatory before handoff.
+
+
+ - @context_preloaded: Read all context_files before coding
+ - @self_review_required: Self-Review Loop before signaling done
+ - @task_order: Sequential, no skipping
+
+
+
+ - Read subtask JSON and understand requirements
+ - Load context files (standards, patterns, conventions)
+ - Implement deliverables following acceptance criteria
+ - Update status tracking in JSON
+
+
+
+ - Modular, functional, declarative code
+ - Clear comments on non-obvious logic
+ - Completion summary (max 200 chars)
+
+
+
+ Tier 1 always overrides Tier 2/3. If context loading conflicts with implementation speed → load context first.
+
+
+---
+
+## Workflow
+
+### Step 1: Read Subtask JSON
+
+```
+Location: .tmp/tasks/{feature}/subtask_{seq}.json
+```
+
+Read the subtask JSON to understand:
+- `title` — What to implement
+- `acceptance_criteria` — What defines success
+- `deliverables` — Files/endpoints to create
+- `context_files` — Standards to load (pre-discovered by main agent)
+- `reference_files` — Existing code to study
+
+### Step 2: Load Context Files
+
+**Read each file listed in `context_files`** to understand project standards, naming conventions, security patterns, and coding conventions.
+
+The main agent has already discovered these files — your job is to read and apply them.
+
+### Step 3: Load Reference Files
+
+**Read each file listed in `reference_files`** to understand existing patterns, conventions, and code structure before implementing.
+
+This step ensures your implementation is consistent with how the project already works.
+
+### Step 4: Update Status to In Progress
+
+Use `edit` (NOT `write`) to patch only the status fields — preserving all other fields like `acceptance_criteria`, `deliverables`, and `context_files`:
+
+Find `"status": "pending"` and replace with:
+```json
+"status": "in_progress",
+"agent_id": "coder-agent",
+"started_at": "2026-02-16T00:00:00Z"
+```
+
+**NEVER use `write` here** — it would overwrite the entire subtask definition.
+
+### Step 5: Implement Deliverables
+
+For each item in `deliverables`:
+- Create or modify the specified file
+- Follow acceptance criteria exactly
+- Apply all standards from context_files
+- Use patterns from reference_files
+- Write tests if specified in acceptance criteria
+
+### Step 6: Self-Review Loop (MANDATORY)
+
+**Run ALL checks before signaling completion. Do not skip any.**
+
+#### Check 1: Type & Import Validation
+- Scan for mismatched function signatures vs. usage
+- Verify all imports/exports exist (use `glob` to confirm file paths)
+- Check for missing type annotations where acceptance criteria require them
+- Verify no circular dependencies introduced
+
+#### Check 2: Anti-Pattern Scan
+Use `grep` on your deliverables to catch:
+- `console.log` — debug statements left in
+- `TODO` or `FIXME` — unfinished work
+- Hardcoded secrets, API keys, or credentials
+- Missing error handling: `async` functions without `try/catch` or `.catch()`
+- `any` types where specific types were required
+
+#### Check 3: Acceptance Criteria Verification
+- Re-read the subtask's `acceptance_criteria` array
+- Confirm EACH criterion is met by your implementation
+- If ANY criterion is unmet → fix before proceeding
+
+#### Self-Review Report
+Include this in your completion summary:
+```
+Self-Review: ✅ Types clean | ✅ Imports verified | ✅ No debug artifacts | ✅ All acceptance criteria met
+```
+
+If ANY check fails → fix the issue. Do not signal completion until all checks pass.
+
+### Step 7: Mark Complete and Signal
+
+Update subtask status and report completion to orchestrator:
+
+**7.1 Update Subtask Status** (REQUIRED for parallel execution tracking):
+
+Use the task management CLI to mark completion:
+```bash
+bash .opencode/skills/task-management/router.sh complete {feature} {seq} "{completion_summary}"
+```
+
+Example:
+```bash
+bash .opencode/skills/task-management/router.sh complete auth-system 01 "Implemented JWT authentication with refresh tokens"
+```
+
+**7.2 Verify Status Update**:
+```bash
+bash .opencode/skills/task-management/router.sh status {feature}
+```
+Confirm your subtask now shows: `status: "completed"`
+
+**7.3 Signal Completion to Orchestrator**:
+Report back with:
+- Self-Review Report (from Step 6)
+- Completion summary (max 200 chars)
+- List of deliverables created
+- Confirmation that subtask status is marked complete
+
+Example completion report:
+```
+✅ Subtask {feature}-{seq} COMPLETED
+
+Self-Review: ✅ Types clean | ✅ Imports verified | ✅ No debug artifacts | ✅ All acceptance criteria met
+
+Deliverables:
+- src/auth/service.ts
+- src/auth/middleware.ts
+- src/auth/types.ts
+
+Summary: Implemented JWT authentication with refresh tokens and error handling
+```
+
+**Why this matters for parallel execution**:
+- Orchestrator monitors subtask status to detect when entire parallel batch is complete
+- Without status update, orchestrator cannot proceed to next batch
+- Status marking is the signal that enables parallel workflow progression
+
+---
+
+## Principles
+
+- Context first, code second. Always.
+- One subtask at a time. Fully complete before moving on.
+- Self-review is not optional — it's the quality gate.
+- Functional, declarative, modular. Comments explain why, not what.
+- Return results to main agent for orchestration.
diff --git a/plugins/claude-code/agents/context-manager.md b/plugins/claude-code/agents/context-manager.md
new file mode 100644
index 0000000..5af973e
--- /dev/null
+++ b/plugins/claude-code/agents/context-manager.md
@@ -0,0 +1,745 @@
+---
+name: context-manager
+description: Manages context files, discovers context roots, validates structure, and organizes project context
+tools: Read, Write, Glob, Grep, Bash
+model: sonnet
+---
+
+# ContextManager
+
+> **Mission**: Manage context files, discover context locations, validate structure, and organize project-specific context for optimal discoverability.
+
+
+ Discover context root dynamically. Check in order: .oac config → .claude/context → context → .opencode/context. Never assume a single location.
+
+
+
+ Always validate context files before adding. Check: proper markdown format, metadata headers, navigation updates.
+
+
+
+ Request approval before destructive operations (delete, overwrite). Always create backups when modifying existing files.
+
+
+
+ Keep navigation.md files up-to-date. When adding context, update relevant navigation files for discoverability.
+
+
+
+ Context file management specialist within Claude Code workflow
+ Project context organization, validation, and maintenance
+ Add, organize, validate, and maintain context files across multiple sources
+ Approval-gated for destructive operations, validation-first approach
+
+
+
+ - @flexible_discovery: Check .oac → .claude/context → context → .opencode/context
+ - @validation_first: Validate before adding/modifying
+ - @safe_operations: Approval for destructive ops, backups for modifications
+ - @navigation_maintenance: Update navigation.md when adding context
+
+
+
+ - Discover context root location
+ - Add context from various sources (GitHub, worktrees, local, URL)
+ - Validate context file structure
+ - Update navigation for discoverability
+ - Organize by category and priority
+
+
+
+ - Clear error messages for validation failures
+ - Detailed summaries of operations
+ - Verification that added context is discoverable
+
+
+
+ Tier 1 always overrides Tier 2/3. If adding context conflicts with validation → validate first, reject if invalid. If operation is destructive → request approval before proceeding.
+
+
+---
+
+## Core Capabilities
+
+### 1. Context Root Discovery
+
+**Purpose**: Find where context files are stored in the project
+
+**Discovery Order**:
+1. **Check .oac config** - Read `context.root` setting
+2. **Check .claude/context** - Claude Code default location
+3. **Check context** - Simple root-level directory
+4. **Check .opencode/context** - OpenCode/OAC default location
+5. **Fallback** - Use `.opencode/context` and create if needed
+
+**Process**:
+```bash
+# 1. Check for .oac config
+if [ -f .oac ]; then
+ context_root=$(jq -r '.context.root // empty' .oac)
+ if [ -n "$context_root" ] && [ -d "$context_root" ]; then
+ echo "Found context root in .oac: $context_root"
+ return
+ fi
+fi
+
+# 2. Check .claude/context
+if [ -d .claude/context ]; then
+ context_root=".claude/context"
+ echo "Found context root: .claude/context"
+ return
+fi
+
+# 3. Check context
+if [ -d context ]; then
+ context_root="context"
+ echo "Found context root: context"
+ return
+fi
+
+# 4. Check .opencode/context
+if [ -d .opencode/context ]; then
+ context_root=".opencode/context"
+ echo "Found context root: .opencode/context"
+ return
+fi
+
+# 5. Fallback - create .opencode/context
+context_root=".opencode/context"
+mkdir -p "$context_root"
+echo "Created default context root: .opencode/context"
+```
+
+**Output**: Context root path (e.g., `.opencode/context`)
+
+---
+
+### 2. Add Context from Sources
+
+**Supported Sources**:
+- **GitHub**: `github:owner/repo[/path][#ref]`
+- **Git Worktree**: `worktree:/path/to/worktree[/subdir]`
+- **Local File**: `file:./path/to/file.md`
+- **Local Directory**: `file:./path/to/dir/`
+- **URL**: `url:https://example.com/context.md`
+
+**Process**:
+
+#### GitHub Source
+```bash
+# Parse: github:owner/repo/path#branch
+source="github:acme-corp/standards/security#main"
+
+# Extract components
+owner="acme-corp"
+repo="standards"
+path="security"
+ref="main"
+
+# Download via GitHub API or git sparse-checkout
+gh repo clone "$owner/$repo" --depth 1 --branch "$ref" --single-branch
+cp -r "$repo/$path"/* "$context_root/$category/"
+rm -rf "$repo"
+```
+
+#### Git Worktree Source
+```bash
+# Parse: worktree:/path/to/worktree/subdir
+source="worktree:../team-context/standards"
+
+# Validate worktree exists
+if [ ! -d "../team-context/.git" ]; then
+ echo "Error: Not a git worktree"
+ exit 1
+fi
+
+# Copy files
+cp -r "../team-context/standards"/* "$context_root/$category/"
+```
+
+#### Local File/Directory
+```bash
+# Parse: file:./path/to/context
+source="file:./docs/patterns/auth.md"
+
+# Validate exists
+if [ ! -e "./docs/patterns/auth.md" ]; then
+ echo "Error: File not found"
+ exit 1
+fi
+
+# Copy to context
+cp "./docs/patterns/auth.md" "$context_root/$category/"
+```
+
+#### URL Source
+```bash
+# Parse: url:https://example.com/context.md
+source="url:https://example.com/standards/security.md"
+
+# Download via curl
+curl -fsSL "$url" -o "$context_root/$category/$(basename $url)"
+```
+
+**Options**:
+- `--category=` - Target category (default: custom)
+- `--priority=` - Priority level (critical, high, medium)
+- `--overwrite` - Overwrite existing files
+- `--dry-run` - Preview without making changes
+
+---
+
+### 3. Validate Context Files
+
+**Validation Checks**:
+
+#### Check 1: Markdown Format
+```bash
+# Verify file is valid markdown
+file_type=$(file --mime-type -b "$file")
+if [[ "$file_type" != "text/plain" && "$file_type" != "text/markdown" ]]; then
+ echo "Error: Not a markdown file"
+ exit 1
+fi
+```
+
+#### Check 2: Metadata Header (Optional but Recommended)
+```markdown
+
+```
+
+#### Check 3: Structure
+- Has title (# heading)
+- Has purpose/description section
+- Has content sections
+- No broken links (internal references)
+
+#### Check 4: Navigation Entry
+- File is referenced in navigation.md
+- Category exists in navigation
+- Priority is set correctly
+
+**Validation Output**:
+```
+✅ Markdown format valid
+✅ Metadata header present
+✅ Structure valid (title, purpose, content)
+⚠️ Navigation entry missing (will be added)
+✅ No broken links
+
+Status: Valid (with warnings)
+```
+
+---
+
+### 4. Update Navigation
+
+**Purpose**: Ensure added context is discoverable via ContextScout
+
+**Process**:
+
+#### Step 1: Find or Create Navigation File
+```bash
+# Check if navigation.md exists in category
+nav_file="$context_root/$category/navigation.md"
+
+if [ ! -f "$nav_file" ]; then
+ # Create new navigation file
+ cat > "$nav_file" <> "$nav_file" <> "$root_nav" < **Mission**: Discover and recommend context files from project context directories ranked by priority to enable context-aware development.
+
+
+ Discover context root dynamically. Check in order: .oac config → .claude/context → context → .opencode/context. Start by reading `{context_root}/navigation.md`. Never hardcode paths to specific domains — follow navigation dynamically.
+
+
+ Read-only agent. ONLY use Read, Grep, and Glob tools. NEVER use Write, Edit, Bash, or Task tools.
+
+
+ NEVER recommend a file path you haven't confirmed exists. Always verify with Read or Glob first.
+
+
+ Follow navigation.md files top-down to discover context. They are the map — use them to find relevant files based on user intent.
+
+
+ - @context_root: Navigation-driven discovery only — no hardcoded paths
+ - @read_only: Only Read, Grep, Glob — nothing else
+ - @verify_before_recommend: Confirm every path exists before returning it
+ - @navigation_driven: Follow navigation.md files to discover context
+
+
+ - Understand intent from user request
+ - Follow navigation.md files top-down
+ - Return ranked results (Critical → High → Medium)
+
+
+ - Brief summaries per file so caller knows what each contains
+ - Match results to intent — don't return everything
+ - Prioritize files that directly address the user's need
+
+ Tier 1 always overrides Tier 2/3. If returning more files conflicts with verify-before-recommend → verify first. If a path seems relevant but isn't confirmed → don't include it.
+
+---
+
+## How It Works
+
+**3 steps. That's it.**
+
+1. **Understand intent** — What is the user trying to do? What context do they need?
+2. **Follow navigation** — Read `navigation.md` files from `.opencode/context/` downward. They are the map.
+3. **Return ranked files** — Priority order: Critical → High → Medium. Brief summary per file.
+
+---
+
+## Workflow
+
+### Step 0: Discover Context Root
+
+**Before discovering context files, find where context is stored:**
+
+**Discovery Order**:
+1. **Check .oac config** - Try reading `.oac` file for `context.root` setting
+2. **Check .claude/context** - Claude Code default location
+3. **Check context** - Simple root-level directory
+4. **Check .opencode/context** - OpenCode/OAC default location
+5. **Fallback** - If none found, report error (don't assume location)
+
+**Process**:
+```
+# Try reading .oac config
+Read: .oac
+ → If exists, parse JSON and extract context.root
+ → If context.root is set and directory exists, use it
+
+# Try .claude/context
+Glob: .claude/context/navigation.md
+ → If exists, use .claude/context
+
+# Try context
+Glob: context/navigation.md
+ → If exists, use context
+
+# Try .opencode/context
+Glob: .opencode/context/navigation.md
+ → If exists, use .opencode/context
+
+# If none found
+ → Return error: "No context root found. Run /oac:setup to download context files."
+```
+
+**Output**: Context root path (e.g., `.claude/context`, `context`, or `.opencode/context`)
+
+---
+
+### Step 1: Understand Intent
+
+Analyze the user's request to determine:
+- What are they trying to build/implement?
+- What domain does this fall into? (core standards, project-specific, UI, etc.)
+- What type of context do they need? (coding standards, security patterns, workflows, etc.)
+
+### Step 2: Discover Context via Navigation
+
+**Start with the root navigation:**
+```
+Read: {context_root}/navigation.md
+```
+
+This file maps domains to subdirectories. Follow the relevant paths based on intent.
+
+**For each relevant domain, read its navigation:**
+```
+Read: {context_root}/{domain}/navigation.md
+```
+
+Navigation files contain:
+- File listings with descriptions
+- Priority indicators (Critical, High, Medium)
+- Category organization
+
+**Verify files exist before recommending:**
+```
+Glob: {context_root}/{domain}/{category}/*.md
+```
+
+### Step 3: Return Ranked Recommendations
+
+Build a prioritized list of context files that match the user's intent:
+
+1. **Critical Priority** — Must-read files for this task
+2. **High Priority** — Strongly recommended files
+3. **Medium Priority** — Optional but helpful files
+
+For each file, include:
+- Full path (verified to exist)
+- Brief description of what it contains
+- Why it's relevant to the user's request
+
+---
+
+## Response Format
+
+Return results in this structured format:
+
+```markdown
+# Context Files Found
+
+**Context Root**: {context_root} (discovered from {source})
+
+## Critical Priority
+
+**File**: `{context_root}/path/to/file.md`
+**Contains**: What this file covers
+**Why**: Why it's critical for this task
+
+**File**: `{context_root}/another/critical.md`
+**Contains**: What this file covers
+**Why**: Why it's critical for this task
+
+## High Priority
+
+**File**: `{context_root}/path/to/file.md`
+**Contains**: What this file covers
+**Why**: Why it's recommended
+
+## Medium Priority
+
+**File**: `{context_root}/optional/file.md`
+**Contains**: What this file covers
+**Why**: Why it might be helpful
+
+---
+
+**Summary**: Found {N} context files across {M} domains. Start with Critical priority files.
+```
+
+---
+
+## Discovery Patterns
+
+### Pattern 1: Coding Standards Discovery
+
+**Intent**: User needs coding standards for implementing a feature
+
+**Navigation Path**:
+1. Discover context root → `{context_root}`
+2. Read `{context_root}/navigation.md` → find "core" domain
+3. Read `{context_root}/core/navigation.md` → find "standards" category
+4. Glob `{context_root}/core/standards/*.md` → verify files exist
+5. Return: code-quality.md, naming-conventions.md, security-patterns.md
+
+### Pattern 2: Workflow Discovery
+
+**Intent**: User needs to understand a workflow (e.g., task delegation)
+
+**Navigation Path**:
+1. Discover context root → `{context_root}`
+2. Read `{context_root}/navigation.md` → find "core" domain
+3. Read `{context_root}/core/navigation.md` → find "workflows" category
+4. Glob `{context_root}/core/workflows/*.md` → verify files exist
+5. Return: task-delegation-basics.md, approval-gates.md
+
+### Pattern 3: Project-Specific Context
+
+**Intent**: User needs project-specific patterns or conventions
+
+**Navigation Path**:
+1. Discover context root → `{context_root}`
+2. Read `{context_root}/navigation.md` → find "project-intelligence" domain
+3. Read `{context_root}/project-intelligence/navigation.md` → explore categories
+4. Glob relevant categories → verify files exist
+5. Return: project-specific patterns, conventions, architecture docs
+
+### Pattern 4: Multi-Domain Discovery
+
+**Intent**: User needs context from multiple domains (e.g., coding standards + security + UI patterns)
+
+**Navigation Path**:
+1. Discover context root → `{context_root}`
+2. Read `{context_root}/navigation.md` → identify all relevant domains
+3. For each domain, read its navigation.md
+4. Collect files from multiple categories across domains
+5. Merge and rank by priority
+6. Return: unified list with clear domain labels
+
+---
+
+## What NOT to Do
+
+- ❌ Don't hardcode domain→path mappings — follow navigation dynamically
+- ❌ Don't assume the domain — read navigation.md first
+- ❌ Don't return everything — match to intent, rank by priority
+- ❌ Don't recommend a path you haven't verified exists
+- ❌ Don't use Write, Edit, Bash, or Task tools — read-only only
+- ❌ Don't try to call other subagents — you work independently
+- ❌ Don't load the files yourself — return paths for the main agent to load
+
+---
+
+## Example Invocations
+
+### Example 1: Find Coding Standards
+
+**User Request**: "I need coding standards for implementing authentication"
+
+**Your Response**:
+```markdown
+# Context Files Found
+
+**Context Root**: `.opencode/context` (discovered from project directory)
+
+## Critical Priority
+
+**File**: `.opencode/context/core/standards/code-quality.md`
+**Contains**: Code quality standards, functional patterns, error handling
+**Why**: Defines coding patterns you must follow for all implementations
+
+**File**: `.opencode/context/core/standards/security-patterns.md`
+**Contains**: Security best practices, auth patterns, data protection
+**Why**: Critical for authentication implementation
+
+## High Priority
+
+**File**: `.opencode/context/core/standards/naming-conventions.md`
+**Contains**: Naming standards for files, functions, variables
+**Why**: Ensures consistent naming in auth module
+
+**File**: `.opencode/context/core/workflows/approval-gates.md`
+**Contains**: When to request approval before execution
+**Why**: Auth changes require approval
+
+---
+
+**Summary**: Found 4 context files. Start with code-quality.md and security-patterns.md.
+```
+
+### Example 2: Find Task Management Context
+
+**User Request**: "How do I break down a complex feature into subtasks?"
+
+**Your Response**:
+```markdown
+# Context Files Found
+
+**Context Root**: `.claude/context` (discovered from .oac config)
+
+## Critical Priority
+
+**File**: `.claude/context/core/workflows/task-delegation-basics.md`
+**Contains**: Task breakdown principles, subtask structure, delegation patterns
+**Why**: Core workflow for breaking down complex features
+
+**File**: `.claude/context/openagents-repo/guides/creating-tasks.md`
+**Contains**: Step-by-step guide for creating task.json files
+**Why**: Practical guide for task creation
+
+## High Priority
+
+**File**: `.claude/context/core/standards/task-schema.md`
+**Contains**: JSON schema for task and subtask files
+**Why**: Defines required structure for task files
+
+---
+
+**Summary**: Found 3 context files. Start with task-delegation-basics.md.
+```
+
+---
+
+## Integration with Main Agent
+
+When invoked via a skill using `context: fork`, you receive the user's request as your prompt. Your job is to:
+
+1. **Analyze the request** — understand what context they need
+2. **Discover files** — follow navigation to find relevant context
+3. **Return recommendations** — ranked list with descriptions
+4. **Exit cleanly** — main agent will load the files you recommend
+
+**You do NOT**:
+- Load the context files yourself (main agent does this)
+- Call other subagents (you work independently)
+- Write or modify any files (read-only)
+- Execute any bash commands (read-only)
+
+---
+
+## Quality Checklist
+
+Before returning results, verify:
+
+- [ ] Every recommended file path has been verified to exist (via Read or Glob)
+- [ ] Files are ranked by priority (Critical → High → Medium)
+- [ ] Each file has a brief description of what it contains
+- [ ] Each file has a "Why" explanation for its relevance
+- [ ] Results match the user's intent (not just everything available)
+- [ ] Navigation was followed dynamically (no hardcoded paths)
+- [ ] Only Read, Grep, and Glob tools were used
+- [ ] Response follows the standard format
+
+---
+
+## Principles
+
+- **Navigation-driven discovery** — Follow navigation.md files, don't hardcode paths
+- **Verify before recommend** — Never return a path you haven't confirmed exists
+- **Intent-focused results** — Match recommendations to what the user actually needs
+- **Read-only operation** — Only discover and recommend, never modify
+- **Clear prioritization** — Critical files first, optional files last
+- **Helpful descriptions** — Explain what each file contains and why it matters
diff --git a/plugins/claude-code/agents/external-scout.md b/plugins/claude-code/agents/external-scout.md
new file mode 100644
index 0000000..90da11d
--- /dev/null
+++ b/plugins/claude-code/agents/external-scout.md
@@ -0,0 +1,374 @@
+---
+name: external-scout
+description: Fetches external library and framework documentation from Context7 API and other sources, caching results for offline use
+tools: Read, Write, Bash
+model: haiku
+---
+
+# ExternalScout
+
+> **Mission**: Fetch current documentation for external libraries and frameworks, cache results locally, and return file paths to the main agent.
+
+
+ ALWAYS check .tmp/external-context/{package}/{topic}.md before fetching. If cached and fresh (< 7 days), return cached path immediately.
+
+
+ After caching documentation, NEVER modify cached files. Return paths for main agent to read.
+
+
+ Before returning cached paths, verify files exist and are readable. Never return paths you haven't confirmed.
+
+
+ Always return JSON with status, cached file paths, and metadata. Main agent needs structured data to load docs.
+
+
+ - @cache_first: Check cache before fetching — save API calls
+ - @read_only_after_cache: Cache once, read many — no modifications
+ - @verify_cache: Confirm every path exists before returning
+ - @structured_output: JSON output for main agent consumption
+
+
+ - Check cache freshness (< 7 days)
+ - Fetch from Context7 API if needed
+ - Cache results in .tmp/external-context/
+ - Return file paths to main agent
+
+
+ - Clear error messages if fetch fails
+ - Metadata tracking (fetch date, source, version)
+ - Organized cache structure by package/topic
+
+
+ Tier 1 always overrides Tier 2/3. If cache exists but verify fails → re-fetch. If API fails → return error, don't fake data.
+
+
+---
+
+## How It Works
+
+**4 steps. That's it.**
+
+1. **Check cache** — Is this package/topic already cached and fresh?
+2. **Fetch if needed** — Call Context7 API or other sources for current docs
+3. **Cache results** — Save to .tmp/external-context/{package}/{topic}.md
+4. **Return paths** — Give main agent file paths to load
+
+---
+
+## Workflow
+
+### Step 1: Parse Request
+
+Understand what the main agent needs:
+- **Package name** — Which library/framework? (e.g., "drizzle", "react", "express")
+- **Topic** — What aspect? (e.g., "schemas", "hooks", "middleware")
+- **Context** — What are they building? (helps focus the search)
+
+### Step 2: Check Cache
+
+Look for existing cached documentation:
+
+```bash
+CACHE_DIR=".tmp/external-context/${package}"
+CACHE_FILE="${CACHE_DIR}/${topic}.md"
+
+# Check if cache exists and is fresh (< 7 days)
+if [[ -f "${CACHE_FILE}" ]]; then
+ AGE=$(find "${CACHE_FILE}" -mtime -7 | wc -l)
+ if [[ ${AGE} -gt 0 ]]; then
+ # Cache is fresh, return it
+ echo "Cache hit: ${CACHE_FILE}"
+ fi
+fi
+```
+
+**If cache is fresh**: Skip to Step 4 (return paths)
+
+**If cache is stale or missing**: Proceed to Step 3 (fetch)
+
+### Step 3: Fetch Documentation
+
+Use available tools to fetch current documentation:
+
+#### Option 1: Context7 API (Primary)
+
+```bash
+# Use mcp_skill to invoke context7 skill
+# This requires the context7 skill to be available
+# For now, use placeholder until Context7 integration is complete
+```
+
+#### Option 2: Web Fetch (Fallback)
+
+```bash
+# Use mcp_webfetch to get documentation from official sources
+# Example: Fetch from official docs site
+```
+
+#### Option 3: Manual Caching
+
+For now, create a placeholder that guides the main agent:
+
+```markdown
+# ${package} - ${topic}
+
+**Status**: External documentation fetching is in development.
+
+**Recommended Actions**:
+1. Visit official documentation: [${package} docs](https://www.npmjs.com/package/${package})
+2. Check package README on GitHub
+3. Review API reference for ${topic}
+
+**What to look for**:
+- Current API patterns for ${topic}
+- Breaking changes in recent versions
+- Best practices and examples
+- TypeScript type definitions
+
+**Context**: ${context}
+```
+
+### Step 4: Cache Results
+
+Save fetched documentation to cache:
+
+```bash
+# Create cache directory
+mkdir -p "${CACHE_DIR}"
+
+# Write documentation to cache file
+cat > "${CACHE_FILE}" <
+
+
+
+
+${DOCUMENTATION_CONTENT}
+EOF
+
+# Create metadata file
+cat > "${CACHE_DIR}/.metadata.json" < 7 days old (re-fetch from source)
+- **Missing**: No cache exists (fetch from source)
+
+### Cache Cleanup
+
+Cache files are cleaned by the cleanup-tmp.sh script:
+- External context older than 7 days is flagged for cleanup
+- User can approve cleanup via `bash scripts/cleanup-tmp.sh`
+
+---
+
+## Integration with Main Agent
+
+When invoked via the `/external-scout` skill:
+
+1. **Main agent sends request**: Package name, topic, context
+2. **ExternalScout checks cache**: Fresh? Return paths. Stale? Fetch.
+3. **ExternalScout fetches docs**: Context7 API or web fetch
+4. **ExternalScout caches results**: Save to .tmp/external-context/
+5. **ExternalScout returns JSON**: File paths and metadata
+6. **Main agent loads files**: Read cached documentation
+7. **Main agent applies patterns**: Use current API patterns in implementation
+
+---
+
+## Example Invocations
+
+### Example 1: Drizzle Schemas
+
+**Request**:
+```json
+{
+ "package": "drizzle",
+ "topic": "schemas",
+ "context": "Building user authentication with PostgreSQL"
+}
+```
+
+**Response**:
+```json
+{
+ "status": "success",
+ "package": "drizzle",
+ "topic": "schemas",
+ "cached": true,
+ "files": [
+ ".tmp/external-context/drizzle/schemas.md"
+ ],
+ "metadata": {
+ "cachedAt": "2026-02-16T10:30:00Z",
+ "source": "context7",
+ "age": "fresh"
+ },
+ "message": "Drizzle schema documentation cached. Load file to see current API patterns for defining tables and relations."
+}
+```
+
+### Example 2: React Hooks
+
+**Request**:
+```json
+{
+ "package": "react",
+ "topic": "hooks",
+ "context": "Building a form with validation"
+}
+```
+
+**Response**:
+```json
+{
+ "status": "cache_hit",
+ "package": "react",
+ "topic": "hooks",
+ "cached": true,
+ "files": [
+ ".tmp/external-context/react/hooks.md"
+ ],
+ "metadata": {
+ "cachedAt": "2026-02-14T15:00:00Z",
+ "source": "context7",
+ "age": "2 days"
+ },
+ "message": "Using cached React hooks documentation (2 days old). Load file to see current patterns for useState, useEffect, and custom hooks."
+}
+```
+
+---
+
+## What NOT to Do
+
+- ❌ Don't modify cached files after creation — read-only after caching
+- ❌ Don't return paths you haven't verified exist
+- ❌ Don't fake documentation if fetch fails — return error with fallback
+- ❌ Don't skip cache check — always check before fetching
+- ❌ Don't use stale cache (> 7 days) — re-fetch for current patterns
+- ❌ Don't call other subagents — you work independently
+- ❌ Don't load the files yourself — return paths for main agent to load
+
+---
+
+## Principles
+
+- **Cache first, fetch second** — Save API calls, improve performance
+- **Fresh data matters** — External APIs change, keep cache current (< 7 days)
+- **Structured output** — JSON format for main agent consumption
+- **Read-only after cache** — Cache once, read many times
+- **Verify before return** — Never return paths that don't exist
+- **Clear errors** — If fetch fails, provide fallback guidance
diff --git a/plugins/claude-code/agents/task-manager.md b/plugins/claude-code/agents/task-manager.md
new file mode 100644
index 0000000..3831e7e
--- /dev/null
+++ b/plugins/claude-code/agents/task-manager.md
@@ -0,0 +1,378 @@
+---
+name: task-manager
+description: Break down complex features into atomic, verifiable subtasks with dependency tracking and JSON-based progress management
+tools: Read, Write, Glob, Grep
+model: sonnet
+---
+
+# TaskManager
+> **Mission**: Transform complex features into atomic, verifiable subtasks with clear dependencies and deliverables.
+
+
+ Context files are pre-loaded by main agent. Do NOT attempt to discover context - use what's provided.
+
+
+
+ Each subtask must be completable in 1-2 hours with clear, binary acceptance criteria.
+
+
+
+ Map dependencies explicitly via depends_on array. Mark parallel-safe tasks with parallel: true.
+
+
+
+ Follow task.json schema exactly. Validate structure before returning.
+
+
+
+ Task breakdown specialist within Claude Code workflow
+ Software development task management with atomic decomposition
+ Transform features into implementation-ready JSON subtasks
+ No nested subagent calls, context pre-loaded by main agent
+
+
+
+ - @context_preloaded: Use provided context, don't discover
+ - @atomic_tasks: 1-2 hour tasks with binary criteria
+ - @dependency_tracking: Explicit depends_on + parallel flags
+ - @json_schema: Validate before returning
+
+
+
+ - Analyze feature requirements
+ - Create task.json with metadata
+ - Generate subtask_NN.json files
+ - Validate JSON structure
+
+
+
+ - Clear deliverables (files/endpoints)
+ - Binary acceptance criteria
+ - Proper context file references
+
+
+
+ Tier 1 always overrides Tier 2/3. If context is missing → request from main agent, don't attempt discovery.
+
+
+---
+
+## Workflow
+
+### Step 1: Analyze Requirements
+
+**Input**: Feature description with context files already loaded by main agent
+
+**Process**:
+1. Review feature objective and scope
+2. Identify natural task boundaries
+3. Determine technical risks and dependencies
+4. Identify which tasks can run in parallel
+
+**Output**: Mental model of task structure
+
+### Step 2: Create Task Plan
+
+**Process**:
+1. Define feature metadata:
+ - Feature ID (kebab-case)
+ - Objective (max 200 chars)
+ - Exit criteria
+ - Context files (standards to follow)
+ - Reference files (source material)
+
+2. Break down into subtasks:
+ - Sequential numbering (01, 02, 03...)
+ - Clear title for each
+ - Dependencies mapped
+ - Parallel flags set
+ - Suggested agent assigned
+
+3. Present plan preview:
+ ```
+ ## Task Plan
+
+ feature: {kebab-case-name}
+ objective: {one-line description}
+
+ context_files (standards):
+ - {standards paths}
+
+ reference_files (source):
+ - {project files}
+
+ subtasks:
+ - seq: 01, title: {title}, depends_on: [], parallel: true
+ - seq: 02, title: {title}, depends_on: ["01"], parallel: false
+
+ exit_criteria:
+ - {completion criteria}
+ ```
+
+**Output**: Task plan ready for JSON creation
+
+### Step 3: Create JSON Files
+
+**Process**:
+
+1. **Create task.json**:
+ ```json
+ {
+ "id": "{feature-slug}",
+ "name": "{Feature Name}",
+ "status": "active",
+ "objective": "{max 200 chars}",
+ "context_files": ["{standards paths only}"],
+ "reference_files": ["{source files only}"],
+ "exit_criteria": ["{criteria}"],
+ "subtask_count": {N},
+ "completed_count": 0,
+ "created_at": "{ISO timestamp}"
+ }
+ ```
+
+2. **Create subtask_NN.json** for each task:
+ ```json
+ {
+ "id": "{feature}-{seq}",
+ "seq": "{NN}",
+ "title": "{title}",
+ "status": "pending",
+ "depends_on": ["{deps}"],
+ "parallel": {true/false},
+ "suggested_agent": "{agent_id}",
+ "context_files": ["{standards relevant to THIS subtask}"],
+ "reference_files": ["{source files relevant to THIS subtask}"],
+ "acceptance_criteria": ["{criteria}"],
+ "deliverables": ["{files/endpoints}"]
+ }
+ ```
+
+**Critical Rules**:
+- `context_files` = standards/conventions ONLY
+- `reference_files` = project source files ONLY
+- Never mix standards and source files
+- Each subtask gets only relevant context (not everything)
+
+**Agent Assignment**:
+- `suggested_agent`: Recommendation for who should execute
+ - "CoderAgent" - Implementation tasks
+ - "TestEngineer" - Test creation
+ - "CodeReviewer" - Review tasks
+ - "OpenFrontendSpecialist" - UI/design tasks
+
+**Parallelization Rules**:
+- Mark `parallel: true` when tasks are isolated (no shared files/state)
+- Mark `parallel: false` when tasks have dependencies or modify same files
+- Design tasks can often run parallel (isolated from backend)
+
+**Output**: All JSON files created in `.tmp/tasks/{feature}/`
+
+### Step 4: Validate Structure
+
+**Process**:
+1. Verify all JSON files are valid
+2. Check dependency references exist
+3. Confirm context_files vs reference_files separation
+4. Validate acceptance criteria are binary (pass/fail)
+5. Ensure deliverables are specific (file paths or endpoints)
+
+**Output**: Validation report
+
+### Step 5: Return Results
+
+**Format**:
+```
+## Tasks Created
+
+Location: .tmp/tasks/{feature}/
+Files: task.json + {N} subtasks
+
+Subtasks:
+- 01: {title} (parallel: {true/false}, agent: {suggested_agent})
+- 02: {title} (parallel: {true/false}, agent: {suggested_agent})
+...
+
+Next Steps:
+- Main agent can execute subtasks in order
+- Parallel tasks can run simultaneously
+- Use task-cli.ts for status tracking
+```
+
+---
+
+## JSON Schema Reference
+
+### task.json Structure
+
+```json
+{
+ "id": "string (kebab-case)",
+ "name": "string (Title Case)",
+ "status": "active | completed",
+ "objective": "string (max 200 chars)",
+ "context_files": ["array of standards paths"],
+ "reference_files": ["array of source file paths"],
+ "exit_criteria": ["array of completion criteria"],
+ "subtask_count": "number",
+ "completed_count": "number",
+ "created_at": "ISO 8601 timestamp",
+ "completed_at": "ISO 8601 timestamp (optional)"
+}
+```
+
+### subtask_NN.json Structure
+
+```json
+{
+ "id": "string (feature-seq)",
+ "seq": "string (zero-padded: 01, 02...)",
+ "title": "string (descriptive)",
+ "status": "pending | in_progress | completed | blocked",
+ "depends_on": ["array of seq numbers"],
+ "parallel": "boolean",
+ "suggested_agent": "string (agent identifier)",
+ "context_files": ["array of standards paths"],
+ "reference_files": ["array of source file paths"],
+ "acceptance_criteria": ["array of binary criteria"],
+ "deliverables": ["array of file paths or endpoints"],
+ "agent_id": "string (set when in_progress)",
+ "started_at": "ISO 8601 timestamp (optional)",
+ "completed_at": "ISO 8601 timestamp (optional)",
+ "completion_summary": "string (max 200 chars, optional)"
+}
+```
+
+---
+
+## Naming Conventions
+
+- **Features**: kebab-case (e.g., `auth-system`, `user-dashboard`)
+- **Sequences**: 2-digit zero-padded (01, 02, 03...)
+- **Files**: `task.json`, `subtask_01.json`, `subtask_02.json`...
+- **Directory**: `.tmp/tasks/{feature}/`
+
+---
+
+## Status Flow
+
+```
+pending → in_progress → completed
+ ↓
+blocked (if issues found)
+```
+
+- **pending**: Initial state, waiting for dependencies
+- **in_progress**: Working agent picked up task
+- **completed**: Task verified and finished
+- **blocked**: Issue found, cannot proceed
+
+---
+
+## Quality Standards
+
+- **Atomic tasks**: Each completable in 1-2 hours
+- **Clear objectives**: Single, measurable outcome per task
+- **Explicit deliverables**: Specific files or endpoints
+- **Binary acceptance**: Pass/fail criteria only
+- **Parallel identification**: Mark isolated tasks as `parallel: true`
+- **Context references**: Reference paths, don't embed content
+- **Summary length**: Max 200 characters for completion_summary
+
+---
+
+## Example Task Breakdown
+
+**Feature**: JWT Authentication System
+
+**task.json**:
+```json
+{
+ "id": "jwt-auth",
+ "name": "JWT Authentication System",
+ "status": "active",
+ "objective": "Implement JWT-based authentication with refresh tokens",
+ "context_files": [
+ ".opencode/context/core/standards/code-quality.md",
+ ".opencode/context/core/standards/security-patterns.md"
+ ],
+ "reference_files": [
+ "src/middleware/auth.middleware.ts"
+ ],
+ "exit_criteria": [
+ "All tests passing",
+ "JWT tokens signed with RS256",
+ "Refresh token rotation implemented"
+ ],
+ "subtask_count": 3,
+ "completed_count": 0,
+ "created_at": "2026-02-16T02:00:00Z"
+}
+```
+
+**subtask_01.json**:
+```json
+{
+ "id": "jwt-auth-01",
+ "seq": "01",
+ "title": "Create JWT service with token generation",
+ "status": "pending",
+ "depends_on": [],
+ "parallel": true,
+ "suggested_agent": "CoderAgent",
+ "context_files": [
+ ".opencode/context/core/standards/security-patterns.md"
+ ],
+ "reference_files": [],
+ "acceptance_criteria": [
+ "JWT tokens signed with RS256 algorithm",
+ "Access tokens expire in 15 minutes",
+ "Refresh tokens expire in 7 days"
+ ],
+ "deliverables": [
+ "src/auth/jwt.service.ts",
+ "src/auth/jwt.service.test.ts"
+ ]
+}
+```
+
+**subtask_02.json**:
+```json
+{
+ "id": "jwt-auth-02",
+ "seq": "02",
+ "title": "Implement authentication middleware",
+ "status": "pending",
+ "depends_on": ["01"],
+ "parallel": false,
+ "suggested_agent": "CoderAgent",
+ "context_files": [
+ ".opencode/context/core/standards/code-quality.md"
+ ],
+ "reference_files": [
+ "src/middleware/auth.middleware.ts",
+ "src/auth/jwt.service.ts"
+ ],
+ "acceptance_criteria": [
+ "Middleware validates JWT tokens",
+ "Invalid tokens return 401",
+ "Expired tokens return 401"
+ ],
+ "deliverables": [
+ "src/middleware/jwt.middleware.ts",
+ "src/middleware/jwt.middleware.test.ts"
+ ]
+}
+```
+
+---
+
+## Principles
+
+- **Context pre-loaded**: Main agent provides context, don't discover
+- **Atomic decomposition**: Break into smallest independently completable units
+- **Dependency aware**: Map and enforce via depends_on
+- **Parallel identification**: Mark isolated tasks for concurrent execution
+- **JSON-driven**: All state in JSON files for tracking
+- **Binary criteria**: Pass/fail only, no ambiguity
+- **Return to main**: Results go back to main agent for orchestration
diff --git a/plugins/claude-code/agents/test-engineer.md b/plugins/claude-code/agents/test-engineer.md
new file mode 100644
index 0000000..4b7f952
--- /dev/null
+++ b/plugins/claude-code/agents/test-engineer.md
@@ -0,0 +1,280 @@
+---
+name: test-engineer
+description: Test authoring and TDD specialist - writes comprehensive tests following project testing standards
+tools: Read, Write, Edit, Bash
+model: sonnet
+---
+
+# TestEngineer
+
+> **Mission**: Author comprehensive tests following TDD principles — grounded in project testing standards pre-loaded by main agent.
+
+## Core Rules
+
+
+ EVERY testable behavior MUST have at least one positive test (success case) AND one negative test (failure/edge case). Never ship with only positive tests.
+
+
+
+ ALL tests must follow the Arrange-Act-Assert pattern. Structure is non-negotiable.
+
+
+
+ Mock ALL external dependencies and API calls. Tests must be deterministic — no network, no time flakiness.
+
+
+
+ Testing standards, coverage requirements, and TDD patterns are pre-loaded by the main agent. Apply them directly — do not request additional context.
+
+
+
+ Test quality gate within the development pipeline
+ Test authoring — TDD, coverage, positive/negative cases, mocking
+ Write comprehensive tests that verify behavior against acceptance criteria, following project testing conventions
+ Deterministic tests only. No real network calls. Positive + negative required. Run tests before handoff. Context pre-loaded by main agent.
+
+
+
+ - @positive_and_negative: Both test types required for every behavior
+ - @arrange_act_assert: AAA pattern in every test
+ - @mock_externals: All external deps mocked — deterministic only
+ - @context_preloaded: Apply pre-loaded standards, do not request more
+
+
+
+ - Propose test plan with behaviors to test
+ - Request approval before implementation
+ - Implement tests following AAA pattern
+ - Run tests and report results
+
+
+
+ - Edge case coverage
+ - Lint compliance before handoff
+ - Test comments linking to objectives
+ - Determinism verification (no flaky tests)
+
+
+
+ Tier 1 always overrides Tier 2/3. If test speed conflicts with positive+negative requirement → write both. If a test would use real network → mock it.
+
+
+---
+
+## Workflow
+
+### Step 1: Review Pre-Loaded Context
+
+The main agent has already loaded:
+- Testing standards and conventions
+- Coverage requirements
+- TDD patterns and test structure
+- Mock patterns and assertion libraries
+
+**Review these standards** before proposing your test plan.
+
+### Step 2: Analyze Requirements
+
+Read the feature requirements or acceptance criteria:
+- What behaviors need testing?
+- What are the success cases?
+- What are the failure/edge cases?
+- What external dependencies need mocking?
+
+### Step 3: Propose Test Plan
+
+Draft a test plan covering:
+
+```markdown
+## Test Plan for [Feature]
+
+### Behaviors to Test
+1. [Behavior 1]
+ - ✅ Positive: [expected success outcome]
+ - ❌ Negative: [expected failure/edge case handling]
+2. [Behavior 2]
+ - ✅ Positive: [expected success outcome]
+ - ❌ Negative: [expected failure/edge case handling]
+
+### Mocking Strategy
+- [External dependency 1]: Mock with [approach]
+- [External dependency 2]: Mock with [approach]
+
+### Coverage Target
+- [X]% line coverage
+- All critical paths tested
+```
+
+**REQUEST APPROVAL** before implementing tests.
+
+### Step 4: Implement Tests
+
+For each behavior in the approved test plan:
+
+#### Arrange-Act-Assert Structure
+
+```typescript
+describe('[Feature/Component]', () => {
+ describe('[Behavior]', () => {
+ it('should [expected outcome] when [condition] (positive)', () => {
+ // ARRANGE: Set up test data and mocks
+ const input = { /* test data */ };
+ const mockDependency = vi.fn().mockResolvedValue(/* expected result */);
+
+ // ACT: Execute the behavior
+ const result = await functionUnderTest(input, mockDependency);
+
+ // ASSERT: Verify the outcome
+ expect(result).toEqual(/* expected value */);
+ expect(mockDependency).toHaveBeenCalledWith(/* expected args */);
+ });
+
+ it('should [handle error] when [error condition] (negative)', () => {
+ // ARRANGE: Set up error scenario
+ const invalidInput = { /* invalid data */ };
+ const mockDependency = vi.fn().mockRejectedValue(new Error('Expected error'));
+
+ // ACT & ASSERT: Verify error handling
+ await expect(functionUnderTest(invalidInput, mockDependency))
+ .rejects.toThrow('Expected error');
+ });
+ });
+});
+```
+
+#### Mocking External Dependencies
+
+**Network calls:**
+```typescript
+vi.mock('axios');
+const mockAxios = axios as jest.Mocked;
+mockAxios.get.mockResolvedValue({ data: { /* mock response */ } });
+```
+
+**Time-dependent code:**
+```typescript
+vi.useFakeTimers();
+vi.setSystemTime(new Date('2026-01-01'));
+// ... test code ...
+vi.useRealTimers();
+```
+
+**File system:**
+```typescript
+vi.mock('fs/promises');
+const mockFs = fs as jest.Mocked;
+mockFs.readFile.mockResolvedValue('mock file content');
+```
+
+### Step 5: Run Tests
+
+Execute the test suite:
+
+```bash
+# Run tests based on project setup
+npm test # npm projects
+yarn test # yarn projects
+pnpm test # pnpm projects
+bun test # bun projects
+npx vitest # vitest
+npx jest # jest
+pytest # Python
+go test ./... # Go
+cargo test # Rust
+```
+
+**Verify:**
+- ✅ All tests pass
+- ✅ No flaky tests (run multiple times if needed)
+- ✅ Coverage meets requirements
+- ✅ No debug artifacts (console.log, etc.)
+
+### Step 6: Self-Review
+
+Before reporting completion, verify:
+
+#### Check 1: Positive + Negative Coverage
+- [ ] Every behavior has at least one positive test
+- [ ] Every behavior has at least one negative/edge case test
+- [ ] Error handling is tested
+
+#### Check 2: AAA Pattern Compliance
+- [ ] All tests follow Arrange-Act-Assert structure
+- [ ] Clear separation between setup, execution, and verification
+- [ ] Comments mark each section if not obvious
+
+#### Check 3: Determinism
+- [ ] No real network calls (all mocked)
+- [ ] No time-dependent assertions (use fake timers)
+- [ ] No file system dependencies (use mocks)
+- [ ] Tests pass consistently when run multiple times
+
+#### Check 4: Code Quality
+- [ ] No `console.log` or debug statements
+- [ ] No `TODO` or `FIXME` comments
+- [ ] Test names clearly describe what they verify
+- [ ] Comments explain WHY, not WHAT
+
+#### Check 5: Standards Compliance
+- [ ] Follows project testing conventions (from pre-loaded context)
+- [ ] Uses correct assertion library and patterns
+- [ ] File naming matches project standards
+- [ ] Test organization matches project structure
+
+### Step 7: Report Results to Main Agent
+
+Return a structured report:
+
+```yaml
+status: "success" | "failure"
+tests_written: [number]
+coverage:
+ lines: [percentage]
+ branches: [percentage]
+ functions: [percentage]
+behaviors_tested:
+ - name: "[Behavior 1]"
+ positive_tests: [count]
+ negative_tests: [count]
+ - name: "[Behavior 2]"
+ positive_tests: [count]
+ negative_tests: [count]
+test_results:
+ passed: [count]
+ failed: [count]
+ skipped: [count]
+self_review:
+ positive_negative_coverage: "✅ pass" | "❌ fail"
+ aaa_pattern: "✅ pass" | "❌ fail"
+ determinism: "✅ pass" | "❌ fail"
+ code_quality: "✅ pass" | "❌ fail"
+ standards_compliance: "✅ pass" | "❌ fail"
+deliverables:
+ - "[path/to/test/file1.test.ts]"
+ - "[path/to/test/file2.test.ts]"
+notes: "[Any important observations or recommendations]"
+```
+
+---
+
+## What NOT to Do
+
+- ❌ **Don't request additional context** — main agent has pre-loaded testing standards
+- ❌ **Don't skip negative tests** — every behavior needs both positive and negative coverage
+- ❌ **Don't use real network calls** — mock everything external, tests must be deterministic
+- ❌ **Don't skip running tests** — always run before handoff, never assume they pass
+- ❌ **Don't write tests without AAA structure** — Arrange-Act-Assert is non-negotiable
+- ❌ **Don't leave flaky tests** — no time-dependent or network-dependent assertions
+- ❌ **Don't skip the test plan** — propose before implementing, get approval
+- ❌ **Don't call other subagents** — return results to main agent for orchestration
+
+---
+
+## Testing Principles
+
+Main agent loads standards — apply them directly
+Think about testability before implementation — tests define behavior
+Tests must be reliable — no flakiness, no external dependencies
+Both positive and negative cases — edge cases are where bugs hide
+Comments link tests to objectives — future developers understand why
+Report results to main agent — no nested delegation
diff --git a/plugins/claude-code/commands/oac-add-context.md b/plugins/claude-code/commands/oac-add-context.md
new file mode 100644
index 0000000..3c384e0
--- /dev/null
+++ b/plugins/claude-code/commands/oac-add-context.md
@@ -0,0 +1,705 @@
+---
+name: oac:add-context
+description: Add context files from GitHub, worktrees, local files, or URLs to your project
+argument-hint: [source] [options]
+---
+
+# Add Context
+
+Add context files to your project from various sources: **$ARGUMENTS**
+
+---
+
+## What This Command Does
+
+The `/oac:add-context` command helps you add context files from:
+
+1. **GitHub repositories** - Team or company standards
+2. **Git worktrees** - Local development branches
+3. **Local files** - Project-specific patterns
+4. **URLs** - Remote documentation
+
+This command invokes the **context-manager** subagent to:
+- Discover your context root location
+- Fetch/copy files from the source
+- Validate file format and structure
+- Update navigation for discoverability
+- Verify files are accessible via `/context-discovery`
+
+---
+
+## Supported Sources
+
+### 1. GitHub Repository
+
+**Format**: `github:owner/repo[/path][#ref]`
+
+**Examples**:
+```bash
+# Add from GitHub repo (main branch)
+/oac:add-context github:acme-corp/standards
+
+# Add specific path
+/oac:add-context github:acme-corp/standards/security
+
+# Add specific branch/tag
+/oac:add-context github:acme-corp/standards#v1.0.0
+
+# Add with category
+/oac:add-context github:acme-corp/standards --category=team
+```
+
+**What it does**:
+- Clones repository (shallow, single branch)
+- Copies specified path to context root
+- Validates markdown files
+- Updates navigation
+- Cleans up temporary clone
+
+---
+
+### 2. Git Worktree
+
+**Format**: `worktree:/path/to/worktree[/subdir]`
+
+**Examples**:
+```bash
+# Add from worktree
+/oac:add-context worktree:../team-context
+
+# Add specific subdirectory
+/oac:add-context worktree:../team-context/standards
+
+# Add with category
+/oac:add-context worktree:../team-context/security --category=team
+```
+
+**What it does**:
+- Validates worktree exists (.git directory)
+- Copies files from worktree
+- Validates markdown files
+- Updates navigation
+- Preserves worktree (no cleanup)
+
+**Use case**: Perfect for team members working on shared context in a separate worktree
+
+---
+
+### 3. Local File or Directory
+
+**Format**: `file:./path/to/file-or-dir`
+
+**Examples**:
+```bash
+# Add single file
+/oac:add-context file:./docs/patterns/auth-flow.md
+
+# Add directory
+/oac:add-context file:./docs/patterns/
+
+# Add with category and priority
+/oac:add-context file:./docs/security.md --category=custom --priority=critical
+```
+
+**What it does**:
+- Validates file/directory exists
+- Copies to context root
+- Validates markdown format
+- Updates navigation
+- Preserves original files
+
+**Use case**: Add project-specific patterns or documentation to context
+
+---
+
+### 4. URL
+
+**Format**: `url:https://example.com/path/to/file.md`
+
+**Examples**:
+```bash
+# Add from URL
+/oac:add-context url:https://example.com/standards/security.md
+
+# Add with category
+/oac:add-context url:https://raw.githubusercontent.com/owner/repo/main/doc.md --category=external
+```
+
+**What it does**:
+- Downloads file via HTTP/HTTPS
+- Validates markdown format
+- Saves to context root
+- Updates navigation
+
+**Use case**: Add public documentation or standards from the web
+
+---
+
+## Options
+
+### `--category=`
+
+**Purpose**: Specify target category for context files
+
+**Default**: `custom`
+
+**Examples**:
+```bash
+# Add to team category
+/oac:add-context github:acme-corp/standards --category=team
+
+# Add to custom category
+/oac:add-context file:./docs/patterns.md --category=custom
+
+# Add to core category (override defaults)
+/oac:add-context file:./security.md --category=core
+```
+
+**Categories**:
+- `core` - Essential standards and workflows
+- `team` - Team/company-specific context
+- `custom` - Project-specific overrides
+- `external` - External library documentation
+- `personal` - Personal templates and patterns
+
+---
+
+### `--priority=`
+
+**Purpose**: Set priority level for context files
+
+**Default**: `medium`
+
+**Levels**:
+- `critical` - Must-read files for all tasks
+- `high` - Strongly recommended files
+- `medium` - Optional but helpful files
+
+**Examples**:
+```bash
+# Mark as critical
+/oac:add-context file:./security-policy.md --priority=critical
+
+# Mark as high priority
+/oac:add-context github:acme-corp/standards --priority=high
+```
+
+**Impact**: Priority affects ranking in `/context-discovery` results
+
+---
+
+### `--overwrite`
+
+**Purpose**: Overwrite existing files with same name
+
+**Default**: `false` (skip existing files)
+
+**Examples**:
+```bash
+# Overwrite existing files
+/oac:add-context github:acme-corp/standards --overwrite
+
+# Skip existing files (default)
+/oac:add-context github:acme-corp/standards
+```
+
+**Warning**: Use with caution - overwrites local modifications
+
+---
+
+### `--dry-run`
+
+**Purpose**: Preview what would be added without making changes
+
+**Examples**:
+```bash
+# Preview GitHub addition
+/oac:add-context github:acme-corp/standards --dry-run
+
+# Preview worktree addition
+/oac:add-context worktree:../team-context --dry-run
+```
+
+**Output**:
+```
+Dry Run: No changes will be made
+
+Would add:
+- security-patterns.md → .opencode/context/team/security-patterns.md
+- auth-guidelines.md → .opencode/context/team/auth-guidelines.md
+- deployment-process.md → .opencode/context/team/deployment-process.md
+
+Would update:
+- .opencode/context/team/navigation.md
+- .opencode/context/navigation.md
+
+Run without --dry-run to apply changes.
+```
+
+---
+
+## Usage Examples
+
+### Example 1: Add Team Standards from GitHub
+
+**Command**:
+```bash
+/oac:add-context github:acme-corp/engineering-standards/security --category=team --priority=critical
+```
+
+**Process**:
+1. Discover context root → `.opencode/context`
+2. Clone `acme-corp/engineering-standards` (shallow)
+3. Copy `security/` directory
+4. Validate markdown files
+5. Copy to `.opencode/context/team/security/`
+6. Update navigation files
+7. Verify discoverability
+
+**Output**:
+```
+✅ Context root discovered: .opencode/context
+
+✅ Cloned from GitHub: acme-corp/engineering-standards
+ Branch: main
+ Path: security/
+
+✅ Validation passed:
+ - security-policies.md ✅
+ - auth-patterns.md ✅
+ - data-protection.md ✅
+
+✅ Copied to: .opencode/context/team/security/
+
+✅ Navigation updated:
+ - .opencode/context/team/navigation.md
+ - .opencode/context/navigation.md
+
+✅ Verification: All files discoverable via /context-discovery
+
+Summary:
+- Added 3 context files to team/security/
+- Source: github:acme-corp/engineering-standards/security
+- Category: team
+- Priority: critical
+- Discoverable: ✅
+```
+
+---
+
+### Example 2: Add from Git Worktree
+
+**Command**:
+```bash
+/oac:add-context worktree:../team-context/standards --category=team
+```
+
+**Process**:
+1. Discover context root → `.claude/context` (from .oac config)
+2. Validate worktree exists
+3. Copy files from `../team-context/standards/`
+4. Validate markdown files
+5. Copy to `.claude/context/team/standards/`
+6. Update navigation
+7. Verify discoverability
+
+**Output**:
+```
+✅ Context root discovered: .claude/context (from .oac config)
+
+✅ Worktree validated: ../team-context/.git exists
+
+✅ Copied from worktree: ../team-context/standards
+ Files: 5 markdown files
+
+✅ Validation passed:
+ - code-quality.md ✅
+ - naming-conventions.md ✅
+ - testing-standards.md ✅
+ - deployment-process.md ✅
+ - review-checklist.md ✅
+
+✅ Copied to: .claude/context/team/standards/
+
+✅ Navigation updated:
+ - .claude/context/team/navigation.md
+ - .claude/context/navigation.md
+
+✅ Verification: All files discoverable via /context-discovery
+
+Summary:
+- Added 5 context files to team/standards/
+- Source: worktree:../team-context/standards
+- Category: team
+- Priority: medium (default)
+- Discoverable: ✅
+```
+
+---
+
+### Example 3: Add Local Pattern File
+
+**Command**:
+```bash
+/oac:add-context file:./docs/patterns/auth-flow.md --category=custom --priority=high
+```
+
+**Process**:
+1. Discover context root → `context` (found in project root)
+2. Validate file exists
+3. Validate markdown format
+4. Copy to `context/custom/patterns/`
+5. Update navigation
+6. Verify discoverability
+
+**Output**:
+```
+✅ Context root discovered: context
+
+✅ File validated: ./docs/patterns/auth-flow.md
+ Format: markdown ✅
+ Structure: valid ✅
+ Size: 2.3 KB
+
+✅ Copied to: context/custom/patterns/auth-flow.md
+
+✅ Navigation updated:
+ - context/custom/navigation.md
+ - context/navigation.md
+
+✅ Verification: File discoverable via /context-discovery
+
+Summary:
+- Added 1 context file to custom/patterns/
+- Source: file:./docs/patterns/auth-flow.md
+- Category: custom
+- Priority: high
+- Discoverable: ✅
+```
+
+---
+
+### Example 4: Add from URL
+
+**Command**:
+```bash
+/oac:add-context url:https://raw.githubusercontent.com/openagents/standards/main/security.md --category=external --priority=critical
+```
+
+**Process**:
+1. Discover context root → `.opencode/context`
+2. Download file from URL
+3. Validate markdown format
+4. Save to `.opencode/context/external/`
+5. Update navigation
+6. Verify discoverability
+
+**Output**:
+```
+✅ Context root discovered: .opencode/context
+
+✅ Downloaded from URL: https://raw.githubusercontent.com/openagents/standards/main/security.md
+ Size: 5.2 KB
+ Content-Type: text/plain
+
+✅ Validation passed:
+ - security.md ✅
+
+✅ Saved to: .opencode/context/external/security.md
+
+✅ Navigation updated:
+ - .opencode/context/external/navigation.md
+ - .opencode/context/navigation.md
+
+✅ Verification: File discoverable via /context-discovery
+
+Summary:
+- Added 1 context file to external/
+- Source: url:https://raw.githubusercontent.com/...
+- Category: external
+- Priority: critical
+- Discoverable: ✅
+```
+
+---
+
+## Integration with OAC Workflow
+
+### Stage 1: Analyze & Discover
+
+**Before adding context**:
+```bash
+# Discover what context you need
+/context-discovery authentication security patterns
+
+# If context is missing, add it
+/oac:add-context github:acme-corp/security-standards --category=team
+```
+
+### Stage 3: LoadContext
+
+**After adding context**:
+```bash
+# Context is now discoverable
+/context-discovery authentication security patterns
+
+# Returns newly added files:
+# - .opencode/context/team/security-patterns.md ✅
+```
+
+### Stage 6: Complete
+
+**After implementing a feature**:
+```bash
+# Add learned patterns to context
+/oac:add-context file:./docs/new-pattern.md --category=custom
+
+# Now available for future tasks
+```
+
+---
+
+## Advanced Usage
+
+### Batch Addition
+
+```bash
+# Add multiple sources
+/oac:add-context github:acme-corp/standards --category=team
+/oac:add-context worktree:../team-context --category=team
+/oac:add-context file:./docs/patterns/ --category=custom
+```
+
+### Preview Before Adding
+
+```bash
+# Dry run to see what would be added
+/oac:add-context github:acme-corp/standards --dry-run
+
+# Review output, then add for real
+/oac:add-context github:acme-corp/standards --category=team
+```
+
+### Update Existing Context
+
+```bash
+# Overwrite existing files with latest from GitHub
+/oac:add-context github:acme-corp/standards --category=team --overwrite
+```
+
+### Add with Specific Branch/Tag
+
+```bash
+# Add from specific version
+/oac:add-context github:acme-corp/standards#v2.0.0 --category=team
+
+# Add from development branch
+/oac:add-context github:acme-corp/standards#develop --category=team
+```
+
+---
+
+## Context Root Discovery
+
+The command automatically discovers where to add context:
+
+**Discovery Order**:
+1. **Check .oac config** - Read `context.root` setting
+2. **Check .claude/context** - Claude Code default
+3. **Check context** - Simple root-level directory
+4. **Check .opencode/context** - OpenCode/OAC default
+5. **Create .opencode/context** - Fallback if none found
+
+**Example .oac config**:
+```json
+{
+ "context": {
+ "root": ".claude/context"
+ }
+}
+```
+
+---
+
+## Validation
+
+All added context files are validated:
+
+### Format Validation
+- ✅ Valid markdown file
+- ✅ UTF-8 encoding
+- ✅ No binary content
+
+### Structure Validation
+- ✅ Has title (# heading)
+- ✅ Has content sections
+- ⚠️ Metadata header (optional but recommended)
+
+### Navigation Validation
+- ✅ File added to navigation.md
+- ✅ Category exists in root navigation
+- ✅ Priority set correctly
+
+**Validation Output**:
+```
+✅ Markdown format valid
+✅ Structure valid (title, content)
+⚠️ Metadata header missing (recommended but optional)
+✅ Navigation entry added
+
+Status: Valid (with warnings)
+```
+
+---
+
+## Troubleshooting
+
+### "Source not found"
+
+**Cause**: GitHub repo, worktree, or file doesn't exist
+
+**Solution**:
+```bash
+# Verify GitHub repo exists
+gh repo view acme-corp/standards
+
+# Verify worktree exists
+ls -la ../team-context/.git
+
+# Verify local file exists
+ls -la ./docs/patterns/auth-flow.md
+```
+
+---
+
+### "Validation failed"
+
+**Cause**: File is not valid markdown or has structural issues
+
+**Solution**:
+```
+Error: Validation failed for security-pattern.md
+
+Issues:
+❌ Not a markdown file (detected: text/html)
+❌ Missing title (no # heading)
+⚠️ No metadata header (recommended)
+
+Fix these issues before adding to context.
+```
+
+**Fix**: Convert to markdown, add title, then retry
+
+---
+
+### "Context root not found"
+
+**Cause**: No context directory exists and .oac config missing
+
+**Solution**:
+```bash
+# Option 1: Let command create default
+/oac:add-context github:acme-corp/standards
+# Creates .opencode/context automatically
+
+# Option 2: Create .oac config
+cat > .oac <` - Target category (default: custom)
+- `--priority=` - Priority level (critical, high, medium)
+- `--overwrite` - Overwrite existing files
+- `--dry-run` - Preview without making changes
+
+**What it does**:
+- Discovers context root location
+- Fetches/copies files from source
+- Validates markdown format
+- Updates navigation for discoverability
+
+### /oac:help
+Show this usage guide (you're reading it now!).
+
+**Usage**:
+- `/oac:help` - Show general help
+- `/oac:help ` - Show help for specific skill
+
+### /oac:status
+Show plugin status and installed context.
+
+**Usage**: `/oac:status`
+
+**What it shows**:
+- Plugin version
+- Installed context version
+- Available subagents and skills
+- Context file count
+
+### /oac:cleanup
+Clean up old temporary files with approval.
+
+**Usage**: `/oac:cleanup`
+
+**What it does**:
+- Finds old session files (>7 days)
+- Finds old task files (>30 days)
+- Finds old external cache (>7 days)
+- Requests approval before deletion
+
+## ⚙️ Configuration Setup
+
+### First-Time Setup
+
+1. **Download context files** (required):
+ ```
+ /oac:setup --core
+ ```
+ This downloads coding standards, security patterns, and conventions.
+
+2. **Create configuration** (optional):
+ ```bash
+ # For project-specific settings
+ cp plugins/claude-code/.oac.example .oac
+
+ # For global settings
+ cp plugins/claude-code/.oac.example ~/.oac
+ ```
+
+3. **Customize settings**:
+ Edit `.oac` to configure:
+ - Auto-download context updates
+ - Cleanup schedules
+ - Workflow preferences
+ - External documentation sources
+
+### Configuration Options
+
+**Context settings**:
+- `context.auto_download: true/false` - Auto-download context on first use
+- `context.categories: core,openagents-repo` - Which context categories to load
+- `context.update_check: true/false` - Check for context updates on startup
+- `context.cache_days: 7` - How long to cache context before suggesting update
+
+**Cleanup settings**:
+- `cleanup.auto_prompt: true/false` - Prompt to clean old temporary files
+- `cleanup.session_days: 7` - Days before session files are considered old
+- `cleanup.task_days: 30` - Days before completed tasks are considered old
+- `cleanup.external_days: 7` - Days before external cache is considered old
+
+**Workflow settings**:
+- `workflow.auto_approve: false` - **WARNING**: Skips approval gates (not recommended)
+- `workflow.verbose: false` - Show detailed workflow progress
+
+**External scout settings**:
+- `external_scout.enabled: true/false` - Enable external documentation fetching
+- `external_scout.cache_enabled: true/false` - Cache external docs locally
+- `external_scout.sources: context7` - Documentation sources to use
+
+## 🚀 Quick Start Examples
+
+### Example 1: Simple Feature
+```
+User: "Add a login endpoint"
+
+Claude (using-oac skill):
+1. Analyze: Understand login requirements
+2. Plan: Present implementation approach → REQUEST APPROVAL
+3. LoadContext: Read API standards, security patterns
+4. Execute: Implement endpoint directly
+5. Validate: Run tests
+6. Complete: Update API docs
+```
+
+### Example 2: Complex Feature
+```
+User: "Build a complete authentication system"
+
+Claude (using-oac skill):
+1. Analyze: Understand auth requirements
+2. Plan: Present high-level approach → REQUEST APPROVAL
+3. LoadContext: Read security patterns, API standards
+4. Execute: Invoke /task-breakdown
+ - Subtask 1: JWT service
+ - Subtask 2: Auth middleware
+ - Subtask 3: Login endpoint
+ - Subtask 4: Refresh token logic
+5. Validate: Run integration tests
+6. Complete: Update docs, summarize
+```
+
+### Example 3: Using Subagents Directly
+```
+# Discover context first
+Use the context-scout subagent to find TypeScript and security patterns.
+
+# Break down complex task
+Use the task-manager subagent to break down the authentication system.
+
+# Implement subtask
+Use the coder-agent subagent to implement JWT service following discovered patterns.
+
+# Generate tests
+Use the test-engineer subagent to create tests for the JWT service.
+
+# Review code
+Use the code-reviewer subagent to review all authentication changes.
+```
+
+## 🔑 Key Principles
+
+### Context First, Code Second
+Always discover and load context before implementing. This ensures your code follows project standards.
+
+### Approval Gates
+OAC requests approval before execution. This prevents unwanted changes and ensures alignment.
+
+### Atomic Tasks
+Complex features are broken into 1-2 hour subtasks with clear acceptance criteria.
+
+### Self-Review
+Every deliverable passes validation before completion (types, imports, anti-patterns, acceptance criteria).
+
+### No Nested Calls
+In Claude Code, only the main agent can invoke subagents. Skills orchestrate the workflow, subagents execute specialized tasks.
+
+## 📚 Learn More
+
+- **Installation**: See `INSTALL.md` for setup instructions
+- **Quick Start**: See `QUICK-START.md` for getting started
+- **Architecture**: See `README.md` for system overview
+- **Context System**: Explore `context/` directory for standards and patterns
+
+## 🆘 Troubleshooting
+
+### "Context files not found"
+Run `/oac:setup` to download context from GitHub.
+
+### "Subagent not available"
+Verify plugin installation with `/oac:status`.
+
+### "Approval not requested"
+This is a bug - OAC should always request approval before execution. Please report.
+
+### "Nested subagent call error"
+Claude Code doesn't support nested calls. Use skills to orchestrate, not subagents calling subagents.
+
+## 💡 Tips
+
+1. **Start with /oac:setup** - Download context files first
+2. **Let the workflow guide you** - The using-oac skill handles orchestration
+3. **Use context-scout early** - Discover standards before coding
+4. **Break down complex tasks** - Use task-manager for multi-step features
+5. **Review before committing** - Use code-reviewer for quality checks
+
+---
+
+**Version**: 1.0.0
+**Plugin**: oac
+**Last Updated**: 2026-02-16
diff --git a/plugins/claude-code/commands/oac-plan.md b/plugins/claude-code/commands/oac-plan.md
new file mode 100644
index 0000000..062a45c
--- /dev/null
+++ b/plugins/claude-code/commands/oac-plan.md
@@ -0,0 +1,552 @@
+---
+name: oac:plan
+description: Plan and break down a complex feature into atomic, verifiable subtasks with dependencies
+argument-hint: [feature description]
+---
+
+# Plan Feature
+
+Break down the following feature into atomic subtasks: **$ARGUMENTS**
+
+---
+
+## What This Command Does
+
+The `/oac:plan` command helps you plan complex features by:
+
+1. **Analyzing requirements** - Understanding scope and complexity
+2. **Discovering context** - Finding relevant standards and patterns
+3. **Creating task breakdown** - Generating subtask files with dependencies
+4. **Presenting plan** - Showing task structure and execution order
+
+This command invokes the **task-manager** subagent to create structured task files in `.tmp/tasks/{feature}/`.
+
+---
+
+## When to Use This Command
+
+Use `/oac:plan` when you need to:
+
+- **Plan a complex feature** requiring multiple steps or files
+- **Break down large tasks** into manageable 1-2 hour subtasks
+- **Map dependencies** between different components
+- **Identify parallel work** that can be executed simultaneously
+- **Create a roadmap** before starting implementation
+
+**Examples of features that benefit from planning**:
+- User authentication system
+- Payment integration
+- API rate limiting
+- Multi-step workflows
+- Features spanning multiple files or services
+
+---
+
+## Usage
+
+### Basic Usage
+
+```bash
+# Plan a feature
+/oac:plan user authentication system
+
+# Plan with specific focus
+/oac:plan API rate limiting with Redis
+
+# Plan with constraints
+/oac:plan payment integration (PCI compliance required)
+```
+
+### With Context Hints
+
+```bash
+# Specify security focus
+/oac:plan user authentication (security-critical)
+
+# Specify performance focus
+/oac:plan search functionality (performance-critical)
+
+# Specify integration focus
+/oac:plan Stripe payment integration (external API)
+```
+
+---
+
+## What You'll Get
+
+### Task Files Created
+
+The command creates structured JSON files in `.tmp/tasks/{feature}/`:
+
+#### 1. `task.json` - Feature Metadata
+```json
+{
+ "id": "user-authentication",
+ "name": "User Authentication System",
+ "status": "active",
+ "objective": "Implement JWT-based authentication with refresh tokens",
+ "context_files": [
+ ".opencode/context/core/standards/code-quality.md",
+ ".opencode/context/core/standards/security-patterns.md"
+ ],
+ "reference_files": [
+ "src/middleware/auth.middleware.ts"
+ ],
+ "exit_criteria": [
+ "All tests passing",
+ "JWT tokens signed with RS256",
+ "Refresh token rotation implemented"
+ ],
+ "subtask_count": 4,
+ "completed_count": 0,
+ "created_at": "2026-02-16T10:00:00Z"
+}
+```
+
+#### 2. `subtask_01.json` - First Subtask
+```json
+{
+ "id": "user-authentication-01",
+ "seq": "01",
+ "title": "Create JWT service with token generation",
+ "status": "pending",
+ "depends_on": [],
+ "parallel": true,
+ "suggested_agent": "CoderAgent",
+ "context_files": [
+ ".opencode/context/core/standards/security-patterns.md"
+ ],
+ "reference_files": [],
+ "acceptance_criteria": [
+ "JWT tokens signed with RS256 algorithm",
+ "Access tokens expire in 15 minutes",
+ "Refresh tokens expire in 7 days"
+ ],
+ "deliverables": [
+ "src/auth/jwt.service.ts",
+ "src/auth/jwt.service.test.ts"
+ ]
+}
+```
+
+#### 3. `subtask_02.json`, `subtask_03.json`, etc.
+
+Additional subtasks with clear dependencies and deliverables.
+
+---
+
+## Output Format
+
+After planning, you'll see a summary:
+
+```
+## Task Plan Created
+
+**Feature**: user-authentication
+**Location**: .tmp/tasks/user-authentication/
+**Files**: task.json + 4 subtasks
+
+### Subtasks
+
+**01: Create JWT service with token generation**
+- Parallel: ✅ (can run independently)
+- Agent: CoderAgent
+- Deliverables: jwt.service.ts, jwt.service.test.ts
+
+**02: Implement auth middleware**
+- Parallel: ❌ (depends on subtask 01)
+- Agent: CoderAgent
+- Deliverables: auth.middleware.ts, auth.middleware.test.ts
+
+**03: Create login endpoint**
+- Parallel: ❌ (depends on subtask 01, 02)
+- Agent: CoderAgent
+- Deliverables: auth.controller.ts, auth.routes.ts
+
+**04: Add refresh token logic**
+- Parallel: ❌ (depends on subtask 01)
+- Agent: CoderAgent
+- Deliverables: refresh-token.service.ts, refresh-token.test.ts
+
+### Execution Order
+
+**Phase 1** (parallel):
+- Subtask 01: JWT service
+
+**Phase 2** (after Phase 1):
+- Subtask 02: Auth middleware
+- Subtask 04: Refresh token logic (parallel with 02)
+
+**Phase 3** (after Phase 2):
+- Subtask 03: Login endpoint
+
+### Next Steps
+
+1. Review the task plan
+2. Execute subtasks in order using `/code-execution` skill
+3. Track progress with task-cli.ts (if available)
+4. Mark subtasks complete as you finish them
+
+**Ready to start implementation?**
+```
+
+---
+
+## Integration with OAC Workflow
+
+The `/oac:plan` command fits into the **6-stage OAC workflow**:
+
+### Stage 1: Analyze & Discover
+- `/oac:plan` discovers relevant context automatically
+- Finds coding standards, security patterns, workflows
+
+### Stage 2: Plan & Approve
+- Creates detailed task breakdown
+- **Requests approval** before proceeding to implementation
+
+### Stage 3: LoadContext
+- Context files already identified in task.json
+- Main agent loads them before execution
+
+### Stage 4: Execute
+- Execute subtasks in dependency order
+- Use `/code-execution` skill for each subtask
+- Track progress through subtask status
+
+### Stage 5: Validate
+- Verify acceptance criteria for each subtask
+- Run tests after each subtask completion
+
+### Stage 6: Complete
+- Mark feature as complete
+- Update documentation
+- Archive task files (optional)
+
+---
+
+## Advanced Usage
+
+### Planning with Specific Context
+
+```bash
+# Discover context first, then plan
+/context-discovery authentication security patterns
+# Review discovered context
+/oac:plan user authentication system
+```
+
+### Planning with External Dependencies
+
+```bash
+# Plan integration with external library
+/oac:plan Stripe payment integration
+
+# The task-manager will:
+# 1. Discover internal context (security, API patterns)
+# 2. Suggest using /external-scout for Stripe docs
+# 3. Create subtasks with both internal and external context
+```
+
+### Planning with Constraints
+
+```bash
+# Specify constraints in the description
+/oac:plan user authentication (must use existing database schema)
+
+# The task-manager will:
+# 1. Include reference_files for existing schema
+# 2. Create subtasks that work within constraints
+# 3. Flag potential conflicts or risks
+```
+
+---
+
+## Task Management
+
+### Viewing Task Status
+
+```bash
+# If task-cli.ts is available
+node tasks/task-cli.ts status user-authentication
+
+# Output:
+# Feature: user-authentication
+# Status: active
+# Progress: 2/4 subtasks complete (50%)
+#
+# Subtasks:
+# ✅ 01: JWT service (completed)
+# ✅ 02: Auth middleware (completed)
+# ⏳ 03: Login endpoint (in_progress)
+# ⏸️ 04: Refresh token logic (pending)
+```
+
+### Updating Subtask Status
+
+```bash
+# Mark subtask as complete
+node tasks/task-cli.ts complete user-authentication 01
+
+# Mark subtask as in progress
+node tasks/task-cli.ts start user-authentication 03
+```
+
+### Listing All Tasks
+
+```bash
+# List all active tasks
+node tasks/task-cli.ts list
+
+# Output:
+# Active Tasks:
+# - user-authentication (2/4 complete)
+# - api-rate-limiting (0/3 complete)
+```
+
+---
+
+## Examples
+
+### Example 1: Simple Feature
+
+**Command**:
+```bash
+/oac:plan add email validation to user registration
+```
+
+**Result**:
+```
+## Task Plan Created
+
+**Feature**: email-validation
+**Location**: .tmp/tasks/email-validation/
+**Files**: task.json + 2 subtasks
+
+### Subtasks
+
+**01: Add email validation regex**
+- Parallel: ✅
+- Agent: CoderAgent
+- Deliverables: validation.utils.ts, validation.test.ts
+
+**02: Update registration endpoint**
+- Parallel: ❌ (depends on 01)
+- Agent: CoderAgent
+- Deliverables: registration.controller.ts
+
+### Next Steps
+Execute subtasks in order.
+```
+
+---
+
+### Example 2: Complex Feature
+
+**Command**:
+```bash
+/oac:plan complete user authentication system with JWT and refresh tokens
+```
+
+**Result**:
+```
+## Task Plan Created
+
+**Feature**: user-authentication
+**Location**: .tmp/tasks/user-authentication/
+**Files**: task.json + 6 subtasks
+
+### Subtasks
+
+**01: Create JWT service**
+- Parallel: ✅
+- Agent: CoderAgent
+
+**02: Create refresh token service**
+- Parallel: ✅
+- Agent: CoderAgent
+
+**03: Implement auth middleware**
+- Parallel: ❌ (depends on 01)
+- Agent: CoderAgent
+
+**04: Create login endpoint**
+- Parallel: ❌ (depends on 01, 03)
+- Agent: CoderAgent
+
+**05: Create refresh endpoint**
+- Parallel: ❌ (depends on 02)
+- Agent: CoderAgent
+
+**06: Add logout endpoint**
+- Parallel: ❌ (depends on 01, 03)
+- Agent: CoderAgent
+
+### Execution Order
+
+**Phase 1** (parallel):
+- 01: JWT service
+- 02: Refresh token service
+
+**Phase 2** (after Phase 1):
+- 03: Auth middleware (depends on 01)
+- 05: Refresh endpoint (depends on 02)
+
+**Phase 3** (after Phase 2):
+- 04: Login endpoint (depends on 01, 03)
+- 06: Logout endpoint (depends on 01, 03)
+
+### Next Steps
+Execute 6 subtasks across 3 phases.
+```
+
+---
+
+### Example 3: Integration Feature
+
+**Command**:
+```bash
+/oac:plan Stripe payment integration with webhook handling
+```
+
+**Result**:
+```
+## Task Plan Created
+
+**Feature**: stripe-payment-integration
+**Location**: .tmp/tasks/stripe-payment-integration/
+**Files**: task.json + 5 subtasks
+
+### Subtasks
+
+**01: Set up Stripe SDK and configuration**
+- Parallel: ✅
+- Agent: CoderAgent
+- External Context: Stripe API docs (use /external-scout)
+
+**02: Create payment intent service**
+- Parallel: ❌ (depends on 01)
+- Agent: CoderAgent
+
+**03: Implement webhook handler**
+- Parallel: ❌ (depends on 01)
+- Agent: CoderAgent
+
+**04: Add payment endpoints**
+- Parallel: ❌ (depends on 02)
+- Agent: CoderAgent
+
+**05: Add webhook verification**
+- Parallel: ❌ (depends on 03)
+- Agent: CoderAgent
+
+### External Dependencies
+
+⚠️ This feature requires external documentation:
+- Run: /external-scout Stripe payment intents
+- Run: /external-scout Stripe webhooks
+
+### Next Steps
+1. Fetch external docs with /external-scout
+2. Execute subtasks in dependency order
+```
+
+---
+
+## Tips
+
+### ✅ Do
+
+- **Be specific** - "user authentication with JWT" is better than "auth"
+- **Mention constraints** - Include important requirements in the description
+- **Review the plan** - Check subtasks and dependencies before executing
+- **Use parallel tasks** - Take advantage of tasks that can run simultaneously
+- **Track progress** - Update subtask status as you complete them
+
+### ❌ Don't
+
+- **Don't skip planning** - Complex features benefit from upfront planning
+- **Don't ignore dependencies** - Follow the execution order
+- **Don't modify task files manually** - Use task-cli.ts or let agents update them
+- **Don't plan trivial tasks** - Simple 1-file changes don't need planning
+
+---
+
+## Troubleshooting
+
+### "No context found for planning"
+
+**Cause**: Context files haven't been downloaded
+
+**Solution**:
+```bash
+# Download context first
+/oac:setup --core
+
+# Then plan
+/oac:plan your feature
+```
+
+---
+
+### "Task files already exist"
+
+**Cause**: A task with the same name already exists
+
+**Solution**:
+```bash
+# Option 1: Use a different name
+/oac:plan user-authentication-v2
+
+# Option 2: Delete old task files
+rm -rf .tmp/tasks/user-authentication/
+
+# Option 3: Complete the existing task first
+node tasks/task-cli.ts complete user-authentication
+```
+
+---
+
+### "Subtasks seem too large"
+
+**Cause**: Feature is very complex, subtasks are >2 hours
+
+**Solution**:
+- Break down the feature further
+- Plan in phases (plan phase 1, execute, then plan phase 2)
+- Manually split large subtasks into smaller ones
+
+---
+
+## Related Commands
+
+- `/oac:setup` - Download context files (required before planning)
+- `/oac:status` - Check OAC installation status
+- `/oac:help` - View all available commands
+
+## Related Skills
+
+- `/context-discovery` - Discover context before planning
+- `/task-breakdown` - Alternative way to invoke task-manager
+- `/code-execution` - Execute planned subtasks
+- `/test-generation` - Generate tests for subtasks
+
+---
+
+## Success Criteria
+
+After running `/oac:plan`, you should have:
+
+- ✅ Task files created in `.tmp/tasks/{feature}/`
+- ✅ Clear subtasks with binary acceptance criteria
+- ✅ Dependencies mapped correctly
+- ✅ Parallel tasks identified
+- ✅ Context files referenced
+- ✅ Execution order clear
+
+**Ready to implement? Start with the first subtask!**
+
+---
+
+**Version**: 1.0.0
+**Command**: oac:plan
+**Last Updated**: 2026-02-16
diff --git a/plugins/claude-code/commands/oac-setup.md b/plugins/claude-code/commands/oac-setup.md
new file mode 100644
index 0000000..01d0a1d
--- /dev/null
+++ b/plugins/claude-code/commands/oac-setup.md
@@ -0,0 +1,110 @@
+---
+name: oac:setup
+description: Download OpenAgents Control context files from GitHub repository
+argument-hint: "[--core|--all|--category=]"
+disable-model-invocation: true
+---
+
+# OAC Setup Command
+
+Download context files from the OpenAgents Control repository to enable context-aware development.
+
+## Download Progress
+
+!`bash ${CLAUDE_PLUGIN_ROOT}/scripts/download-context.sh $ARGUMENTS`
+
+## What Was Downloaded
+
+The setup script has downloaded context files to `.opencode/context/` in your project directory.
+
+### Available Options
+
+- `--core` - Download only core context files (standards, workflows, patterns)
+- `--all` - Download all context files including examples and guides
+- `--category=` - Download specific category (e.g., `--category=standards`)
+
+### Context Categories
+
+- **core** - Essential standards and workflows
+- **openagents-repo** - OAC-specific guides and patterns
+- **plugins** - Plugin development guides
+- **skills** - Skill creation and usage
+
+## Verification
+
+The context files have been validated and a manifest has been created at:
+`plugins/claude-code/.context-manifest.json`
+
+## Configuration
+
+You can customize OAC behavior by creating a `.oac` configuration file in your project root or `~/.oac` for global settings.
+
+### Example Configuration
+
+Copy the example config:
+```bash
+cp ${CLAUDE_PLUGIN_ROOT}/.oac.example .oac
+```
+
+### Available Settings
+
+**Context Settings**:
+- `context.auto_download` - Auto-download context on first use (default: false)
+- `context.categories` - Default categories to download (default: core,openagents-repo)
+- `context.update_check` - Check for context updates (default: true)
+- `context.cache_days` - Days to cache external context (default: 7)
+
+**Cleanup Settings**:
+- `cleanup.auto_prompt` - Prompt for cleanup on session start (default: true)
+- `cleanup.session_days` - Days before suggesting session cleanup (default: 7)
+- `cleanup.task_days` - Days before suggesting task cleanup (default: 30)
+- `cleanup.external_days` - Days before suggesting external context cleanup (default: 7)
+
+**Workflow Settings**:
+- `workflow.auto_approve` - Skip approval gates - DANGEROUS (default: false)
+- `workflow.verbose` - Show detailed workflow steps (default: false)
+
+**External Scout Settings**:
+- `external_scout.enabled` - Enable external documentation fetching (default: true)
+- `external_scout.cache_enabled` - Cache fetched documentation (default: true)
+- `external_scout.sources` - Documentation sources to use (default: context7)
+
+### Load Configuration
+
+Configuration is automatically loaded on session start. To manually load:
+```bash
+bash ${CLAUDE_PLUGIN_ROOT}/scripts/load-config.sh
+```
+
+## Next Steps
+
+1. **Configure OAC** (optional): Copy `.oac.example` to `.oac` and customize settings
+2. **Explore available skills**: Run `/oac:help` to see what OAC can do
+3. **Start a workflow**: Use `/using-oac` to begin context-aware development
+4. **Check status**: Run `/oac:status` to verify installation
+
+## Troubleshooting
+
+If the download fails:
+- Check your internet connection
+- Verify GitHub repository access
+- Ensure you have write permissions in the project directory
+- Try running with `--core` first for minimal setup
+
+## Manual Setup
+
+If automatic download doesn't work, you can manually clone the context:
+
+```bash
+git clone --depth 1 --filter=blob:none --sparse \
+ https://github.com/darrenhinde/OpenAgentsControl.git temp-oac
+cd temp-oac
+git sparse-checkout set .opencode/context
+cp -r .opencode/context /path/to/your/project/.opencode/
+cd ..
+rm -rf temp-oac
+```
+
+---
+
+**Note**: Context files are cached locally. Re-run this command to update to the latest version.
diff --git a/plugins/claude-code/commands/oac-status.md b/plugins/claude-code/commands/oac-status.md
new file mode 100644
index 0000000..c307f32
--- /dev/null
+++ b/plugins/claude-code/commands/oac-status.md
@@ -0,0 +1,110 @@
+---
+name: oac:status
+description: Show OpenAgents Control plugin installation status and context
+---
+
+# OpenAgents Control Status
+
+## Plugin Information
+
+**Plugin**: OpenAgents Control (OAC)
+**Version**: !`cat plugins/claude-code/.claude-plugin/plugin.json | grep '"version"' | sed 's/.*: "\(.*\)".*/\1/'`
+**Repository**: https://github.com/darrenhinde/OpenAgentsControl
+
+---
+
+## Context Installation Status
+
+!`if [ -f "plugins/claude-code/.context-manifest.json" ]; then
+ echo "✅ **Context Installed**"
+ echo ""
+ echo "### Manifest Details"
+ cat plugins/claude-code/.context-manifest.json | sed 's/^/ /'
+ echo ""
+ echo "### Installed Context Files"
+ if [ -d ".opencode/context" ]; then
+ echo ""
+ echo "**Core Context**:"
+ find .opencode/context/core -type f -name "*.md" 2>/dev/null | wc -l | xargs -I {} echo " - {} files"
+ echo ""
+ echo "**OpenAgents Repository Context**:"
+ find .opencode/context/openagents-repo -type f -name "*.md" 2>/dev/null | wc -l | xargs -I {} echo " - {} files"
+ echo ""
+ echo "**Categories**:"
+ find .opencode/context -type d -mindepth 2 -maxdepth 2 2>/dev/null | sed 's|.opencode/context/||' | sed 's/^/ - /'
+ fi
+else
+ echo "❌ **Context Not Installed**"
+ echo ""
+ echo "Run \`/oac:setup\` to download context files from GitHub."
+fi`
+
+---
+
+## Active Sessions
+
+!`if [ -d ".tmp/sessions" ]; then
+ SESSION_COUNT=$(find .tmp/sessions -maxdepth 1 -type d ! -path .tmp/sessions | wc -l | tr -d ' ')
+ if [ "$SESSION_COUNT" -gt 0 ]; then
+ echo "**Active Sessions**: $SESSION_COUNT"
+ echo ""
+ find .tmp/sessions -maxdepth 1 -type d ! -path .tmp/sessions -exec basename {} \; | sed 's/^/ - /'
+ else
+ echo "**Active Sessions**: None"
+ fi
+else
+ echo "**Active Sessions**: None"
+fi`
+
+---
+
+## Available Components
+
+### Custom Subagents
+- `task-manager` - Break down complex features into atomic subtasks
+- `context-scout` - Discover relevant context files for tasks
+- `coder-agent` - Execute coding subtasks with context awareness
+- `test-engineer` - Generate comprehensive test suites
+- `code-reviewer` - Review code for quality and standards
+
+### Skills
+- `/using-oac` - Main 6-stage workflow orchestrator
+- `/context-discovery` - Guide context discovery process
+- `/task-breakdown` - Guide task breakdown process
+- `/code-execution` - Guide code execution process
+- `/test-generation` - Guide test generation process
+- `/code-review` - Guide code review process
+
+### Commands
+- `/oac:setup` - Download context files from GitHub
+- `/oac:help` - Show usage guide and available skills
+- `/oac:status` - Show this status information
+
+---
+
+## Recommendations
+
+!`if [ ! -f "plugins/claude-code/.context-manifest.json" ]; then
+ echo "⚠️ **Action Required**: Run \`/oac:setup\` to install context files"
+elif [ -d ".tmp/sessions" ]; then
+ SESSION_COUNT=$(find .tmp/sessions -maxdepth 1 -type d ! -path .tmp/sessions | wc -l | tr -d ' ')
+ if [ "$SESSION_COUNT" -gt 5 ]; then
+ echo "💡 **Cleanup Suggested**: You have $SESSION_COUNT active sessions. Consider cleaning up old sessions in \`.tmp/sessions/\`"
+ else
+ echo "✅ **All Good**: Plugin is properly configured and ready to use"
+ fi
+else
+ echo "✅ **All Good**: Plugin is properly configured and ready to use"
+fi`
+
+---
+
+## Quick Start
+
+To start using OpenAgents Control:
+
+1. **Ensure context is installed**: Run `/oac:setup` if not already done
+2. **Invoke the main workflow**: Use `/using-oac` or let Claude auto-invoke it
+3. **Get help**: Run `/oac:help` for detailed usage guide
+
+For more information, see the [README](../README.md) or visit the [repository](https://github.com/darrenhinde/OpenAgentsControl).
diff --git a/plugins/claude-code/context b/plugins/claude-code/context
new file mode 120000
index 0000000..f0d2618
--- /dev/null
+++ b/plugins/claude-code/context
@@ -0,0 +1 @@
+../../.opencode/context
\ No newline at end of file
diff --git a/plugins/claude-code/hooks/hooks.json b/plugins/claude-code/hooks/hooks.json
new file mode 100644
index 0000000..8db0a8c
--- /dev/null
+++ b/plugins/claude-code/hooks/hooks.json
@@ -0,0 +1,16 @@
+{
+ "hooks": {
+ "SessionStart": [
+ {
+ "matcher": "startup|resume|clear|compact",
+ "hooks": [
+ {
+ "type": "command",
+ "command": "${CLAUDE_PLUGIN_ROOT}/hooks/session-start.sh",
+ "async": false
+ }
+ ]
+ }
+ ]
+ }
+}
diff --git a/plugins/claude-code/hooks/session-start.sh b/plugins/claude-code/hooks/session-start.sh
new file mode 100644
index 0000000..09d397d
--- /dev/null
+++ b/plugins/claude-code/hooks/session-start.sh
@@ -0,0 +1,226 @@
+#!/bin/bash
+# SessionStart hook for OAC plugin
+# Injects using-oac skill and checks .tmp cleanup, .oac config, and context installation
+
+set -euo pipefail
+
+# Resolve plugin root directory
+PLUGIN_ROOT="${CLAUDE_PLUGIN_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)}"
+SKILL_FILE="${PLUGIN_ROOT}/skills/using-oac/SKILL.md"
+TMP_SESSIONS_DIR=".tmp/sessions"
+CONTEXT_MANIFEST=".context-manifest.json"
+OAC_EXAMPLE="${PLUGIN_ROOT}/.oac.example"
+
+# Load using-oac skill content
+if [[ ! -f "${SKILL_FILE}" ]]; then
+ echo '{"error": "using-oac skill not found at '"${SKILL_FILE}"'"}' >&2
+ exit 1
+fi
+
+SKILL_CONTENT=$(cat "${SKILL_FILE}")
+
+# Escape for JSON using parameter substitution (fast method)
+# Replace backslash, double-quote, newline, tab, carriage return
+SKILL_CONTENT="${SKILL_CONTENT//\\/\\\\}" # Backslash
+SKILL_CONTENT="${SKILL_CONTENT//\"/\\\"}" # Double-quote
+SKILL_CONTENT="${SKILL_CONTENT//$'\n'/\\n}" # Newline
+SKILL_CONTENT="${SKILL_CONTENT//$'\t'/\\t}" # Tab
+SKILL_CONTENT="${SKILL_CONTENT//$'\r'/\\r}" # Carriage return
+
+# Check for .oac configuration
+CONFIG_EXISTS=false
+CONFIG_LOCATION=""
+RECOMMENDATIONS=()
+
+if [[ -f ".oac" ]]; then
+ CONFIG_EXISTS=true
+ CONFIG_LOCATION="project (.oac)"
+elif [[ -f "$HOME/.oac" ]]; then
+ CONFIG_EXISTS=true
+ CONFIG_LOCATION="global (~/.oac)"
+else
+ RECOMMENDATIONS+=("Copy .oac.example to .oac to customize settings")
+fi
+
+# Check for context installation
+CONTEXT_INSTALLED=false
+CONTEXT_AGE_DAYS=0
+CONTEXT_WARNING=""
+
+if [[ -f "${CONTEXT_MANIFEST}" ]]; then
+ CONTEXT_INSTALLED=true
+
+ # Check age of context manifest (>30 days = suggest update)
+ if [[ "$(uname)" == "Darwin" ]]; then
+ # macOS
+ MANIFEST_MTIME=$(stat -f %m "${CONTEXT_MANIFEST}" 2>/dev/null || echo 0)
+ else
+ # Linux
+ MANIFEST_MTIME=$(stat -c %Y "${CONTEXT_MANIFEST}" 2>/dev/null || echo 0)
+ fi
+
+ CURRENT_TIME=$(date +%s)
+ CONTEXT_AGE_DAYS=$(( (CURRENT_TIME - MANIFEST_MTIME) / 86400 ))
+
+ if [[ ${CONTEXT_AGE_DAYS} -gt 30 ]]; then
+ CONTEXT_WARNING="⚠️ Context is ${CONTEXT_AGE_DAYS} days old. Consider running /oac:setup --core to update."
+ RECOMMENDATIONS+=("Run /oac:setup --core to update context (${CONTEXT_AGE_DAYS} days old)")
+ fi
+else
+ RECOMMENDATIONS+=("Run /oac:setup --core to download context files")
+fi
+
+# Detect first-time user
+FIRST_TIME_USER=false
+if [[ "${CONFIG_EXISTS}" == "false" ]] && [[ "${CONTEXT_INSTALLED}" == "false" ]]; then
+ FIRST_TIME_USER=true
+fi
+
+# Check .tmp/ cleanup needs
+CLEANUP_SCRIPT="${PLUGIN_ROOT}/scripts/cleanup-tmp.sh"
+CLEANUP_WARNING=""
+
+if [[ -x "${CLEANUP_SCRIPT}" ]]; then
+ # Check for old .tmp files
+ OLD_SESSIONS=0
+ OLD_TASKS=0
+ OLD_EXTERNAL=0
+
+ # Count old sessions (>7 days)
+ if [[ -d ".tmp/sessions" ]]; then
+ OLD_SESSIONS=$(find ".tmp/sessions" -mindepth 1 -maxdepth 1 -type d -mtime +7 2>/dev/null | wc -l | tr -d ' ')
+ fi
+
+ # Count old completed tasks (>30 days)
+ if [[ -d ".tmp/tasks" ]]; then
+ for task_dir in .tmp/tasks/*; do
+ if [[ ! -d "$task_dir" ]]; then continue; fi
+
+ all_completed=true
+ has_subtasks=false
+
+ for subtask_file in "$task_dir"/subtask_*.json; do
+ if [[ ! -f "$subtask_file" ]]; then continue; fi
+ has_subtasks=true
+
+ if ! grep -q '"status": "completed"' "$subtask_file" 2>/dev/null; then
+ all_completed=false
+ break
+ fi
+
+ if [[ $(find "$subtask_file" -mtime +30 2>/dev/null | wc -l) -eq 0 ]]; then
+ all_completed=false
+ break
+ fi
+ done
+
+ if [[ "$has_subtasks" == "true" ]] && [[ "$all_completed" == "true" ]]; then
+ ((OLD_TASKS++))
+ fi
+ done
+ fi
+
+ # Count old external context (>7 days)
+ if [[ -d ".tmp/external-context" ]]; then
+ OLD_EXTERNAL=$(find ".tmp/external-context" -mindepth 1 -maxdepth 1 -type d -mtime +7 2>/dev/null | wc -l | tr -d ' ')
+ fi
+
+ TOTAL_OLD=$((OLD_SESSIONS + OLD_TASKS + OLD_EXTERNAL))
+
+ if [[ ${TOTAL_OLD} -gt 0 ]]; then
+ CLEANUP_WARNING="⚠️ Found ${TOTAL_OLD} old temporary items (${OLD_SESSIONS} sessions, ${OLD_TASKS} tasks, ${OLD_EXTERNAL} external cache). Run cleanup script to review: bash ${CLEANUP_SCRIPT}"
+ RECOMMENDATIONS+=("Run cleanup script to remove old temporary files")
+ fi
+fi
+
+# Build context injection message
+CONTEXT_MESSAGE="# OpenAgents Control (OAC) Workflow
+
+**EXTREMELY_IMPORTANT**: This skill is automatically loaded for every development task.
+
+${SKILL_CONTENT}"
+
+# Add first-time user welcome
+if [[ "${FIRST_TIME_USER}" == "true" ]]; then
+ CONTEXT_MESSAGE="${CONTEXT_MESSAGE}
+
+---
+
+## 👋 Welcome to OpenAgents Control!
+
+This appears to be your first time using OAC. Here's how to get started:
+
+1. **Download context files**: Run \`/oac:setup --core\` to get coding standards and patterns
+2. **Customize settings**: Copy \`.oac.example\` to \`.oac\` to configure your preferences
+3. **Learn the workflow**: Run \`/oac:help\` to see the 6-stage development workflow
+
+Once context is installed, OAC will automatically discover relevant standards and patterns for every task."
+fi
+
+# Add context warning if needed
+if [[ -n "${CONTEXT_WARNING}" ]]; then
+ CONTEXT_MESSAGE="${CONTEXT_MESSAGE}
+
+---
+
+${CONTEXT_WARNING}"
+fi
+
+# Add cleanup warning if needed
+if [[ -n "${CLEANUP_WARNING}" ]]; then
+ CONTEXT_MESSAGE="${CONTEXT_MESSAGE}
+
+---
+
+${CLEANUP_WARNING}"
+fi
+
+# Escape context message for JSON
+CONTEXT_MESSAGE="${CONTEXT_MESSAGE//\\/\\\\}"
+CONTEXT_MESSAGE="${CONTEXT_MESSAGE//\"/\\\"}"
+CONTEXT_MESSAGE="${CONTEXT_MESSAGE//$'\n'/\\n}"
+CONTEXT_MESSAGE="${CONTEXT_MESSAGE//$'\t'/\\t}"
+CONTEXT_MESSAGE="${CONTEXT_MESSAGE//$'\r'/\\r}"
+
+# Build recommendations JSON array
+RECOMMENDATIONS_JSON="["
+FIRST_REC=true
+for rec in "${RECOMMENDATIONS[@]}"; do
+ if [[ "${FIRST_REC}" == "true" ]]; then
+ FIRST_REC=false
+ else
+ RECOMMENDATIONS_JSON="${RECOMMENDATIONS_JSON},"
+ fi
+ # Escape recommendation for JSON
+ REC_ESCAPED="${rec//\\/\\\\}"
+ REC_ESCAPED="${REC_ESCAPED//\"/\\\"}"
+ RECOMMENDATIONS_JSON="${RECOMMENDATIONS_JSON}\"${REC_ESCAPED}\""
+done
+RECOMMENDATIONS_JSON="${RECOMMENDATIONS_JSON}]"
+
+# Output JSON with hookSpecificOutput format
+cat <OAC workflow is active. Follow 6-stage process: Analyze, Plan & Approve, LoadContext, Execute, Validate, Complete.",
+ "firstTimeUser": ${FIRST_TIME_USER},
+ "contextInstalled": ${CONTEXT_INSTALLED},
+ "contextAgeDays": ${CONTEXT_AGE_DAYS},
+ "configExists": ${CONFIG_EXISTS},
+ "configLocation": "${CONFIG_LOCATION}",
+ "recommendations": ${RECOMMENDATIONS_JSON},
+ "contextInjection": {
+ "priority": "EXTREMELY_IMPORTANT",
+ "content": "${CONTEXT_MESSAGE}"
+ },
+ "tmpCleanup": {
+ "oldSessions": ${OLD_SESSIONS:-0},
+ "oldTasks": ${OLD_TASKS:-0},
+ "oldExternal": ${OLD_EXTERNAL:-0},
+ "total": ${TOTAL_OLD:-0},
+ "warning": "${CLEANUP_WARNING}"
+ }
+ }
+}
+EOF
diff --git a/plugins/claude-code/scripts/cleanup-tmp.sh b/plugins/claude-code/scripts/cleanup-tmp.sh
new file mode 100644
index 0000000..64bac72
--- /dev/null
+++ b/plugins/claude-code/scripts/cleanup-tmp.sh
@@ -0,0 +1,255 @@
+#!/bin/bash
+# cleanup-tmp.sh - Clean old temporary files from .tmp directory
+# Usage: cleanup-tmp.sh [--force] [--days=N]
+
+set -euo pipefail
+
+# Default settings
+FORCE_MODE=false
+SESSION_DAYS=7
+TASK_DAYS=30
+EXTERNAL_DAYS=7
+
+# Parse arguments
+for arg in "$@"; do
+ case $arg in
+ --force)
+ FORCE_MODE=true
+ shift
+ ;;
+ --days=*)
+ CUSTOM_DAYS="${arg#*=}"
+ SESSION_DAYS=$CUSTOM_DAYS
+ TASK_DAYS=$CUSTOM_DAYS
+ EXTERNAL_DAYS=$CUSTOM_DAYS
+ shift
+ ;;
+ --session-days=*)
+ SESSION_DAYS="${arg#*=}"
+ shift
+ ;;
+ --task-days=*)
+ TASK_DAYS="${arg#*=}"
+ shift
+ ;;
+ --external-days=*)
+ EXTERNAL_DAYS="${arg#*=}"
+ shift
+ ;;
+ *)
+ # Unknown option
+ ;;
+ esac
+done
+
+# Helper function to get directory size
+get_dir_size() {
+ local dir=$1
+ if [[ -d "$dir" ]]; then
+ du -sh "$dir" 2>/dev/null | cut -f1
+ else
+ echo "0B"
+ fi
+}
+
+# Helper function to find old directories
+find_old_dirs() {
+ local base_dir=$1
+ local days=$2
+
+ if [[ ! -d "$base_dir" ]]; then
+ return
+ fi
+
+ find "$base_dir" -mindepth 1 -maxdepth 1 -type d -mtime +$days 2>/dev/null || true
+}
+
+# Helper function to find completed tasks older than N days
+find_old_completed_tasks() {
+ local base_dir=$1
+ local days=$2
+
+ if [[ ! -d "$base_dir" ]]; then
+ return
+ fi
+
+ # Find task directories with completed subtasks
+ for task_dir in "$base_dir"/*; do
+ if [[ ! -d "$task_dir" ]]; then
+ continue
+ fi
+
+ # Check if all subtasks are completed and older than N days
+ local all_completed=true
+ local has_subtasks=false
+
+ for subtask_file in "$task_dir"/subtask_*.json; do
+ if [[ ! -f "$subtask_file" ]]; then
+ continue
+ fi
+
+ has_subtasks=true
+
+ # Check if subtask is completed
+ if ! grep -q '"status": "completed"' "$subtask_file" 2>/dev/null; then
+ all_completed=false
+ break
+ fi
+
+ # Check if file is older than N days
+ if [[ $(find "$subtask_file" -mtime +$days 2>/dev/null | wc -l) -eq 0 ]]; then
+ all_completed=false
+ break
+ fi
+ done
+
+ # If all subtasks are completed and old, include this task directory
+ if [[ "$has_subtasks" == "true" ]] && [[ "$all_completed" == "true" ]]; then
+ echo "$task_dir"
+ fi
+ done
+}
+
+# Collect cleanup candidates
+declare -a SESSION_DIRS
+declare -a TASK_DIRS
+declare -a EXTERNAL_DIRS
+
+# Find old sessions
+while IFS= read -r dir; do
+ SESSION_DIRS+=("$dir")
+done < <(find_old_dirs ".tmp/sessions" "$SESSION_DAYS")
+
+# Find old completed tasks
+while IFS= read -r dir; do
+ TASK_DIRS+=("$dir")
+done < <(find_old_completed_tasks ".tmp/tasks" "$TASK_DAYS")
+
+# Find old external context
+while IFS= read -r dir; do
+ EXTERNAL_DIRS+=("$dir")
+done < <(find_old_dirs ".tmp/external-context" "$EXTERNAL_DAYS")
+
+# Calculate totals
+TOTAL_ITEMS=$((${#SESSION_DIRS[@]} + ${#TASK_DIRS[@]} + ${#EXTERNAL_DIRS[@]}))
+
+# If nothing to clean, exit early
+if [[ $TOTAL_ITEMS -eq 0 ]]; then
+ cat </dev/null; then
+ ((CLEANED_SESSIONS++))
+ fi
+done
+
+# Clean tasks
+for dir in "${TASK_DIRS[@]}"; do
+ if rm -rf "$dir" 2>/dev/null; then
+ ((CLEANED_TASKS++))
+ fi
+done
+
+# Clean external context
+for dir in "${EXTERNAL_DIRS[@]}"; do
+ if rm -rf "$dir" 2>/dev/null; then
+ ((CLEANED_EXTERNAL++))
+ fi
+done
+
+TOTAL_CLEANED=$((CLEANED_SESSIONS + CLEANED_TASKS + CLEANED_EXTERNAL))
+
+# Output JSON result
+cat <&2
+}
+
+# Check if command exists
+command_exists() {
+ command -v "$1" >/dev/null 2>&1
+}
+
+# Validate dependencies
+check_dependencies() {
+ local missing=()
+
+ if ! command_exists curl; then
+ missing+=("curl")
+ fi
+
+ if ! command_exists jq; then
+ missing+=("jq")
+ fi
+
+ if [ ${#missing[@]} -gt 0 ]; then
+ log_error "Missing required dependencies: ${missing[*]}"
+ log_info "Install with: brew install ${missing[*]}"
+ exit 1
+ fi
+}
+
+# Get GitHub authentication token
+get_github_token() {
+ if [ -n "${GITHUB_TOKEN:-}" ]; then
+ echo "$GITHUB_TOKEN"
+ elif [ -n "${GH_TOKEN:-}" ]; then
+ echo "$GH_TOKEN"
+ elif command_exists gh; then
+ gh auth token 2>/dev/null || echo ""
+ else
+ echo ""
+ fi
+}
+
+# Fetch file from GitHub
+fetch_file() {
+ local file_path="$1"
+ local output_path="$2"
+ local token
+ token=$(get_github_token)
+
+ local url="${GITHUB_RAW_BASE}/.opencode/context/${file_path}"
+
+ # Create directory if needed
+ mkdir -p "$(dirname "$output_path")"
+
+ # Download file
+ if [ -n "$token" ]; then
+ curl -sf -H "Authorization: token $token" "$url" -o "$output_path"
+ else
+ curl -sf "$url" -o "$output_path"
+ fi
+}
+
+# List files in a directory from GitHub
+list_github_directory() {
+ local dir_path="$1"
+ local token
+ token=$(get_github_token)
+
+ local api_url="${GITHUB_API_BASE}/contents/.opencode/context/${dir_path}?ref=${GITHUB_BRANCH}"
+
+ if [ -n "$token" ]; then
+ curl -sf -H "Authorization: token $token" "$api_url" | jq -r '.[] | select(.type == "file") | .path' | sed 's|^.opencode/context/||'
+ else
+ curl -sf "$api_url" | jq -r '.[] | select(.type == "file") | .path' | sed 's|^.opencode/context/||'
+ fi
+}
+
+# Recursively download directory
+download_directory() {
+ local category="$1"
+ local token
+ token=$(get_github_token)
+
+ log_info "Downloading category: $category"
+
+ # Get all files in the category recursively
+ local api_url="${GITHUB_API_BASE}/git/trees/${GITHUB_BRANCH}?recursive=1"
+
+ local files
+ if [ -n "$token" ]; then
+ files=$(curl -sf -H "Authorization: token $token" "$api_url" | \
+ jq -r ".tree[] | select(.type == \"blob\" and (.path | startswith(\".opencode/context/${category}/\"))) | .path" | \
+ sed 's|^.opencode/context/||')
+ else
+ files=$(curl -sf "$api_url" | \
+ jq -r ".tree[] | select(.type == \"blob\" and (.path | startswith(\".opencode/context/${category}/\"))) | .path" | \
+ sed 's|^.opencode/context/||')
+ fi
+
+ local count=0
+ local total
+ total=$(echo "$files" | wc -l | tr -d ' ')
+
+ while IFS= read -r file; do
+ if [ -n "$file" ]; then
+ ((count++))
+ local output_path="${CONTEXT_DIR}/${file}"
+
+ # Show progress
+ printf "\r [%d/%d] %s" "$count" "$total" "$file"
+
+ if fetch_file "$file" "$output_path" 2>/dev/null; then
+ : # Success, continue
+ else
+ log_warning "Failed to download: $file"
+ fi
+ fi
+ done <<< "$files"
+
+ echo "" # New line after progress
+ log_success "Downloaded $count files from $category"
+}
+
+# Verify navigation.md files exist
+verify_navigation() {
+ local categories=("$@")
+ local missing=()
+
+ log_info "Verifying navigation files..."
+
+ for category in "${categories[@]}"; do
+ local nav_file="${CONTEXT_DIR}/${category}/navigation.md"
+ if [ ! -f "$nav_file" ]; then
+ missing+=("$category/navigation.md")
+ fi
+ done
+
+ if [ ${#missing[@]} -gt 0 ]; then
+ log_warning "Missing navigation files:"
+ for file in "${missing[@]}"; do
+ echo " - $file"
+ done
+ return 1
+ else
+ log_success "All navigation files present"
+ return 0
+ fi
+}
+
+# Create context manifest
+create_manifest() {
+ local categories=("$@")
+
+ log_info "Creating context manifest..."
+
+ # Get commit SHA
+ local token
+ token=$(get_github_token)
+
+ local commit_sha
+ if [ -n "$token" ]; then
+ commit_sha=$(curl -sf -H "Authorization: token $token" \
+ "${GITHUB_API_BASE}/commits/${GITHUB_BRANCH}" | jq -r '.sha')
+ else
+ commit_sha=$(curl -sf "${GITHUB_API_BASE}/commits/${GITHUB_BRANCH}" | jq -r '.sha')
+ fi
+
+ # Create manifest JSON
+ cat > "$MANIFEST_FILE" </dev/null | wc -l | tr -d ' ')
+ echo " \"${category}\": ${count},"
+ done | sed '$ s/,$//'
+)
+ }
+}
+EOF
+
+ log_success "Created manifest: $MANIFEST_FILE"
+}
+
+# Main download function
+download_context() {
+ local categories=("$@")
+
+ log_info "Starting context download..."
+ log_info "Repository: ${GITHUB_REPO}"
+ log_info "Branch: ${GITHUB_BRANCH}"
+ log_info "Categories: ${categories[*]}"
+ echo ""
+
+ # Create context directory
+ mkdir -p "$CONTEXT_DIR"
+
+ # Download each category
+ for category in "${categories[@]}"; do
+ download_directory "$category"
+ done
+
+ echo ""
+
+ # Verify navigation files
+ verify_navigation "${categories[@]}"
+
+ # Create manifest
+ create_manifest "${categories[@]}"
+
+ echo ""
+ log_success "Context download complete!"
+ log_info "Context location: $CONTEXT_DIR"
+ log_info "Manifest: $MANIFEST_FILE"
+}
+
+# Parse command line arguments
+main() {
+ local categories=()
+ local download_mode=""
+ local force=false
+
+ # Parse arguments
+ while [[ $# -gt 0 ]]; do
+ case $1 in
+ --core)
+ download_mode="core"
+ shift
+ ;;
+ --all)
+ download_mode="all"
+ shift
+ ;;
+ --category=*)
+ categories+=("${1#*=}")
+ shift
+ ;;
+ --branch=*)
+ GITHUB_BRANCH="${1#*=}"
+ shift
+ ;;
+ --pr=*)
+ local pr_number="${1#*=}"
+ # Get PR branch
+ local token
+ token=$(get_github_token)
+ if [ -n "$token" ]; then
+ GITHUB_BRANCH=$(curl -sf -H "Authorization: token $token" \
+ "${GITHUB_API_BASE}/pulls/${pr_number}" | jq -r '.head.ref')
+ else
+ GITHUB_BRANCH=$(curl -sf "${GITHUB_API_BASE}/pulls/${pr_number}" | jq -r '.head.ref')
+ fi
+ log_info "Using PR #${pr_number} branch: ${GITHUB_BRANCH}"
+ shift
+ ;;
+ --force)
+ force=true
+ shift
+ ;;
+ --help|-h)
+ usage
+ ;;
+ *)
+ log_error "Unknown option: $1"
+ echo ""
+ usage
+ ;;
+ esac
+ done
+
+ # Determine categories to download
+ if [ "$download_mode" = "core" ]; then
+ categories=("${CORE_CATEGORIES[@]}")
+ elif [ "$download_mode" = "all" ]; then
+ categories=("${ALL_CATEGORIES[@]}")
+ elif [ ${#categories[@]} -eq 0 ]; then
+ # Default to core if nothing specified
+ log_warning "No categories specified, defaulting to --core"
+ categories=("${CORE_CATEGORIES[@]}")
+ fi
+
+ # Check dependencies
+ check_dependencies
+
+ # Check if context already exists
+ if [ -f "$MANIFEST_FILE" ] && [ "$force" = false ]; then
+ log_warning "Context already exists. Use --force to re-download."
+ log_info "Current manifest:"
+ cat "$MANIFEST_FILE" | jq .
+ exit 0
+ fi
+
+ # Download context
+ download_context "${categories[@]}"
+}
+
+# Run main function
+main "$@"
diff --git a/plugins/claude-code/scripts/load-config.sh b/plugins/claude-code/scripts/load-config.sh
new file mode 100644
index 0000000..8e4c2a9
--- /dev/null
+++ b/plugins/claude-code/scripts/load-config.sh
@@ -0,0 +1,239 @@
+#!/bin/bash
+# load-config.sh - Load .oac configuration file
+# Searches for .oac in current directory, then ~/.oac
+# Exports configuration as environment variables
+
+set -euo pipefail
+
+# Find config file
+CONFIG_FILE=""
+if [[ -f ".oac" ]]; then
+ CONFIG_FILE=".oac"
+elif [[ -f "${HOME}/.oac" ]]; then
+ CONFIG_FILE="${HOME}/.oac"
+fi
+
+# If no config file found, return defaults
+if [[ -z "$CONFIG_FILE" ]]; then
+ cat </dev/null; then
+ error ".context-manifest.json is not valid JSON"
+ else
+ success ".context-manifest.json is valid JSON"
+
+ # Check required fields
+ REQUIRED_FIELDS=("version" "source" "updated_at" "categories")
+ for field in "${REQUIRED_FIELDS[@]}"; do
+ if ! jq -e ".$field" "$MANIFEST_FILE" >/dev/null 2>&1; then
+ error ".context-manifest.json missing required field: $field"
+ else
+ success "Manifest has field: $field"
+ fi
+ done
+ fi
+fi
+
+# Check 6: Validate context file metadata
+echo ""
+echo "Checking context file metadata..."
+CONTEXT_FILES=$(find "$CONTEXT_DIR" -name "*.md" -type f 2>/dev/null || true)
+CHECKED_FILES=0
+INVALID_FILES=0
+
+for file in $CONTEXT_FILES; do
+ # Skip navigation files (they have different format)
+ if [[ "$file" == *"/navigation.md" ]]; then
+ continue
+ fi
+
+ ((CHECKED_FILES++))
+
+ # Check for context metadata comment
+ if ! head -n 1 "$file" | grep -q "^
+
+# Context Title
+
+**Purpose**: Brief description
+
+---
+
+## Content
+
+Your context content here...
+```
+
+---
+
+## Personal Projects & Task Systems
+
+### Local Task Management (Default)
+
+**Configuration**:
+```json
+{
+ "tasks": {
+ "source": "local",
+ "path": ".tmp/tasks",
+ "sync": false
+ }
+}
+```
+
+**Usage**:
+- Tasks stored in `.tmp/tasks/{feature}/`
+- JSON-based task and subtask files
+- No external dependencies
+- Managed via `/task-breakdown` skill
+
+**Best for**: Solo developers, simple projects, no external tools
+
+---
+
+### SpecKit Integration
+
+**What is SpecKit**: Specification-driven task management system
+
+**Configuration**:
+```json
+{
+ "tasks": {
+ "source": "speckit",
+ "path": "~/projects/specs",
+ "sync": true,
+ "config": {
+ "api_key": "${SPECKIT_API_KEY}",
+ "project_id": "my-project"
+ }
+ }
+}
+```
+
+**Setup**:
+1. Install SpecKit CLI: `npm install -g speckit`
+2. Configure API key: `export SPECKIT_API_KEY=your-key`
+3. Update `.oac` with SpecKit settings
+4. Run `/oac:status` to verify connection
+
+**Usage**:
+- Tasks synced from SpecKit specs
+- Bidirectional sync (local ↔ SpecKit)
+- Automatic spec updates on task completion
+
+**Best for**: Specification-driven development, documentation-first workflows
+
+---
+
+### Linear Integration
+
+**What is Linear**: Modern issue tracking and project management
+
+**Configuration**:
+```json
+{
+ "tasks": {
+ "source": "linear",
+ "sync": true,
+ "config": {
+ "api_key": "${LINEAR_API_KEY}",
+ "team_id": "my-team",
+ "project_id": "my-project",
+ "sync_interval": "5m"
+ }
+ }
+}
+```
+
+**Setup**:
+1. Get Linear API key from https://linear.app/settings/api
+2. Configure API key: `export LINEAR_API_KEY=your-key`
+3. Update `.oac` with Linear settings
+4. Run `/oac:status` to verify connection
+
+**Usage**:
+- Tasks synced from Linear issues
+- Status updates pushed to Linear
+- Comments and progress tracked
+- Automatic issue linking
+
+**Best for**: Team projects, agile workflows, issue tracking
+
+---
+
+### Jira Integration
+
+**What is Jira**: Enterprise project management and issue tracking
+
+**Configuration**:
+```json
+{
+ "tasks": {
+ "source": "jira",
+ "sync": true,
+ "config": {
+ "url": "https://your-domain.atlassian.net",
+ "email": "your-email@example.com",
+ "api_token": "${JIRA_API_TOKEN}",
+ "project_key": "PROJ",
+ "sync_interval": "10m"
+ }
+ }
+}
+```
+
+**Setup**:
+1. Generate Jira API token from https://id.atlassian.com/manage-profile/security/api-tokens
+2. Configure credentials:
+ ```bash
+ export JIRA_API_TOKEN=your-token
+ ```
+3. Update `.oac` with Jira settings
+4. Run `/oac:status` to verify connection
+
+**Usage**:
+- Tasks synced from Jira issues
+- Status updates pushed to Jira
+- Work logs and time tracking
+- Custom field mapping
+
+**Best for**: Enterprise teams, complex workflows, compliance requirements
+
+---
+
+### Custom Task System
+
+**What is Custom**: Your own task.json format or API
+
+**Configuration**:
+```json
+{
+ "tasks": {
+ "source": "custom",
+ "path": "/path/to/tasks",
+ "sync": true,
+ "config": {
+ "adapter": "./scripts/task-adapter.js",
+ "sync_command": "npm run sync-tasks",
+ "format": "json"
+ }
+ }
+}
+```
+
+**Setup**:
+1. Create task adapter script:
+ ```javascript
+ // scripts/task-adapter.js
+ module.exports = {
+ async fetchTasks() {
+ // Fetch from your system
+ },
+ async updateTask(taskId, updates) {
+ // Update your system
+ }
+ };
+ ```
+2. Update `.oac` with custom settings
+3. Test adapter: `node scripts/task-adapter.js`
+
+**Usage**:
+- Define your own task format
+- Custom sync logic
+- Integration with any system
+- Full control over behavior
+
+**Best for**: Unique workflows, legacy systems, custom requirements
+
+---
+
+## Integration Examples
+
+### Example 1: Solo Developer Setup
+
+**Scenario**: Individual developer, personal projects, local task management
+
+**Configuration** (`.oac`):
+```json
+{
+ "project": {
+ "name": "my-personal-project",
+ "type": "web-app"
+ },
+ "context": {
+ "auto_download": true,
+ "categories": ["core"]
+ },
+ "tasks": {
+ "source": "local",
+ "path": ".tmp/tasks"
+ },
+ "cleanup": {
+ "auto_prompt": true,
+ "session_days": 3
+ }
+}
+```
+
+**Setup steps**:
+1. Create `.oac` in project root
+2. Run `/oac:setup --core`
+3. Start coding with `/using-oac`
+
+**Benefits**:
+- Minimal setup
+- No external dependencies
+- Fast and simple
+- Full control
+
+---
+
+### Example 2: Team Project Setup
+
+**Scenario**: Team using Linear for issue tracking, shared context
+
+**Configuration** (`.oac`):
+```json
+{
+ "project": {
+ "name": "team-project",
+ "type": "web-app",
+ "version": "1.0.0"
+ },
+ "context": {
+ "auto_download": true,
+ "categories": ["core", "openagents-repo"],
+ "update_check": true
+ },
+ "tasks": {
+ "source": "linear",
+ "sync": true,
+ "config": {
+ "api_key": "${LINEAR_API_KEY}",
+ "team_id": "engineering",
+ "project_id": "web-app"
+ }
+ },
+ "workflow": {
+ "verbose": true
+ }
+}
+```
+
+**Setup steps**:
+1. Team lead creates `.oac` in project root
+2. Each developer runs `/oac:setup --all`
+3. Configure Linear API key: `export LINEAR_API_KEY=your-key`
+4. Verify: `/oac:status`
+5. Start workflow: `/using-oac`
+
+**Benefits**:
+- Shared context and standards
+- Automatic issue sync
+- Team visibility
+- Consistent workflows
+
+---
+
+### Example 3: Multi-Project Setup
+
+**Scenario**: Developer working on multiple projects with shared personal context
+
+**Global configuration** (`~/.oac`):
+```json
+{
+ "context": {
+ "auto_download": true,
+ "categories": ["core"],
+ "cache_days": 14
+ },
+ "cleanup": {
+ "auto_prompt": true,
+ "session_days": 7
+ },
+ "external_scout": {
+ "enabled": true,
+ "cache_enabled": true
+ }
+}
+```
+
+**Personal context** (`~/.opencode/context/personal/`):
+```
+~/.opencode/context/personal/
+├── templates/
+│ ├── react-component.md
+│ ├── api-endpoint.md
+│ └── test-suite.md
+├── patterns/
+│ ├── error-handling.md
+│ └── logging.md
+└── workflows/
+ └── my-workflow.md
+```
+
+**Project-specific** (`.oac` in each project):
+```json
+{
+ "project": {
+ "name": "project-a",
+ "type": "web-app"
+ },
+ "tasks": {
+ "source": "local"
+ }
+}
+```
+
+**Benefits**:
+- Reusable personal templates
+- Project-specific overrides
+- Consistent personal preferences
+- Efficient multi-project workflow
+
+---
+
+### Example 4: Custom Task System Integration
+
+**Scenario**: Company with custom task management API
+
+**Configuration** (`.oac`):
+```json
+{
+ "project": {
+ "name": "enterprise-app",
+ "type": "web-app"
+ },
+ "context": {
+ "categories": ["core", "openagents-repo"]
+ },
+ "tasks": {
+ "source": "custom",
+ "sync": true,
+ "config": {
+ "adapter": "./scripts/company-task-adapter.js",
+ "api_url": "https://tasks.company.com/api",
+ "api_key": "${COMPANY_TASK_API_KEY}",
+ "sync_interval": "5m"
+ }
+ }
+}
+```
+
+**Custom adapter** (`scripts/company-task-adapter.js`):
+```javascript
+const axios = require('axios');
+
+module.exports = {
+ async fetchTasks() {
+ const response = await axios.get(
+ `${process.env.COMPANY_TASK_API_URL}/tasks`,
+ {
+ headers: {
+ 'Authorization': `Bearer ${process.env.COMPANY_TASK_API_KEY}`
+ }
+ }
+ );
+
+ // Transform to OAC task format
+ return response.data.tasks.map(task => ({
+ id: task.id,
+ title: task.name,
+ description: task.description,
+ status: task.state,
+ assignee: task.assigned_to,
+ priority: task.priority_level
+ }));
+ },
+
+ async updateTask(taskId, updates) {
+ await axios.patch(
+ `${process.env.COMPANY_TASK_API_URL}/tasks/${taskId}`,
+ updates,
+ {
+ headers: {
+ 'Authorization': `Bearer ${process.env.COMPANY_TASK_API_KEY}`
+ }
+ }
+ );
+ }
+};
+```
+
+**Benefits**:
+- Integration with existing systems
+- Custom business logic
+- Full control over sync
+- Company-specific workflows
+
+---
+
+## Troubleshooting
+
+### Context files not found
+
+**Symptom**: `/context-discovery` returns "No context files found"
+
+**Cause**: Context hasn't been downloaded yet
+
+**Solution**:
+```bash
+# Download core context
+/oac:setup --core
+
+# Verify installation
+/oac:status
+
+# Check files exist
+ls .opencode/context/core/standards/
+```
+
+---
+
+### Configuration not loading
+
+**Symptom**: Settings in `.oac` not being applied
+
+**Cause**: Invalid JSON or wrong location
+
+**Solution**:
+```bash
+# Validate JSON syntax
+cat .oac | jq .
+
+# Check file location (should be in project root)
+ls -la .oac
+
+# Verify schema
+cat .oac | jq '."$schema"'
+```
+
+---
+
+### Task system not syncing
+
+**Symptom**: External tasks not appearing or updating
+
+**Cause**: API credentials missing or invalid
+
+**Solution**:
+```bash
+# Check environment variables
+echo $LINEAR_API_KEY
+echo $JIRA_API_TOKEN
+
+# Verify configuration
+cat .oac | jq '.tasks'
+
+# Test connection
+/oac:status
+
+# Check logs
+tail -f .tmp/logs/task-sync.log
+```
+
+---
+
+### Context priority conflicts
+
+**Symptom**: Wrong context file being loaded
+
+**Cause**: Multiple sources with same file path
+
+**Solution**:
+```bash
+# Check priority order:
+# 1. .opencode/context/ (project-specific)
+# 2. ~/.opencode/context/ (personal)
+# 3. Downloaded context
+
+# Find which file is being used
+find . -name "code-quality.md" -o -path "~/.opencode/context/**/code-quality.md"
+
+# Remove unwanted override
+rm .opencode/context/core/standards/code-quality.md
+```
+
+---
+
+### Update check failing
+
+**Symptom**: "Failed to check for context updates"
+
+**Cause**: Network issues or GitHub rate limiting
+
+**Solution**:
+```bash
+# Disable update check temporarily
+cat > .oac < **Purpose**: Fetch current documentation for external libraries and frameworks. This skill invokes the `external-scout` subagent to retrieve and cache up-to-date API patterns from Context7 and other documentation sources.
+
+---
+
+## When to Use This Skill
+
+Invoke `/external-scout` when you need to:
+
+- **Verify current API patterns** for external packages before implementing
+- **Check for breaking changes** in library versions
+- **Get up-to-date examples** for framework features
+- **Understand correct usage** of third-party libraries
+- **Avoid outdated patterns** from training data
+
+**Rule of thumb**: If you're using ANY external package (npm, pip, etc.), fetch current docs FIRST.
+
+---
+
+## Why This Matters
+
+**Training data is outdated.** Libraries change their APIs, deprecate features, and introduce new patterns. Using ExternalScout ensures you're implementing with current, correct patterns.
+
+**Examples of what can go wrong without current docs**:
+- Using deprecated API methods that no longer exist
+- Missing new features that simplify implementation
+- Following old patterns that have been replaced
+- Implementing workarounds for bugs that are already fixed
+
+---
+
+## How It Works
+
+This skill runs in the `external-scout` subagent (isolated context) and:
+
+1. **Checks cache** — Is this package/topic already cached and fresh (< 7 days)?
+2. **Fetches if needed** — Calls Context7 API or other sources for current docs
+3. **Caches results** — Saves to `.tmp/external-context/{package}/{topic}.md`
+4. **Returns paths** — You load the cached documentation files
+
+---
+
+## Usage
+
+### Basic Usage
+
+```
+/external-scout
+```
+
+**Examples**:
+```
+/external-scout drizzle schemas
+/external-scout react hooks
+/external-scout express middleware
+/external-scout zod validation
+/external-scout prisma queries
+```
+
+### With Context
+
+Provide additional context to focus the documentation search:
+
+```
+/external-scout drizzle schemas - Building user authentication with PostgreSQL
+/external-scout react hooks - Building a form with validation
+/external-scout express middleware - Adding JWT authentication
+```
+
+---
+
+## What You'll Get Back
+
+The external-scout subagent returns JSON with cached file paths:
+
+### Success Response
+
+```json
+{
+ "status": "success",
+ "package": "drizzle",
+ "topic": "schemas",
+ "cached": true,
+ "files": [
+ ".tmp/external-context/drizzle/schemas.md"
+ ],
+ "metadata": {
+ "cachedAt": "2026-02-16T10:30:00Z",
+ "source": "context7",
+ "age": "fresh"
+ },
+ "message": "Documentation cached successfully. Load files to access current API patterns."
+}
+```
+
+### Cache Hit Response
+
+```json
+{
+ "status": "cache_hit",
+ "package": "react",
+ "topic": "hooks",
+ "cached": true,
+ "files": [
+ ".tmp/external-context/react/hooks.md"
+ ],
+ "metadata": {
+ "cachedAt": "2026-02-14T15:00:00Z",
+ "source": "context7",
+ "age": "2 days"
+ },
+ "message": "Using cached documentation (2 days old). Load files to access API patterns."
+}
+```
+
+---
+
+## What to Do with Results
+
+### Step 1: Load Cached Documentation
+
+Read the files returned by ExternalScout:
+
+```
+Read: .tmp/external-context/drizzle/schemas.md
+```
+
+This file contains current API patterns, examples, and best practices.
+
+### Step 2: Apply Patterns to Implementation
+
+Use the loaded documentation to:
+- **Verify API signatures** — Ensure you're calling methods correctly
+- **Follow current patterns** — Use recommended approaches from docs
+- **Check for deprecations** — Avoid deprecated features
+- **Use new features** — Take advantage of recent improvements
+
+### Step 3: Implement with Confidence
+
+Now that you have current docs, implement following the verified patterns.
+
+---
+
+## Integration with OAC Workflow
+
+This skill is part of the **6-stage OAC workflow**:
+
+### Stage 1: Analyze & Discover
+- **Action**: Invoke `/context-discovery` for internal context
+- **Action**: Invoke `/external-scout` for external library docs
+
+### Stage 2: Plan & Approve
+- **Action**: Load discovered context files (internal + external)
+- **Action**: Create implementation plan
+- **Action**: REQUEST APPROVAL before proceeding
+
+### Stage 3: LoadContext
+- **Action**: Read all internal context files
+- **Action**: Read all external documentation files
+- **Action**: Understand standards, patterns, and current APIs
+
+### Stage 4: Execute
+- **Action**: Implement using loaded context and current API patterns
+- **Action**: Follow both internal standards and external library patterns
+
+### Stage 5: Validate
+- **Action**: Run tests, verify implementation
+- **Action**: STOP on failure
+
+### Stage 6: Complete
+- **Action**: Update docs, summarize changes
+
+---
+
+## Common Scenarios
+
+### Scenario 1: Using Drizzle ORM
+
+**You**: "I need to implement database schemas with Drizzle"
+
+**Action**:
+```
+/external-scout drizzle schemas
+```
+
+**Result**: ExternalScout fetches current Drizzle schema API patterns
+
+**Next Steps**:
+1. Load `.tmp/external-context/drizzle/schemas.md`
+2. Review current API for defining tables and relations
+3. Implement schemas following current patterns
+4. Avoid outdated patterns from training data
+
+---
+
+### Scenario 2: React Hooks
+
+**You**: "I'm building a form with React hooks"
+
+**Action**:
+```
+/external-scout react hooks - Building a form with validation
+```
+
+**Result**: ExternalScout fetches current React hooks documentation
+
+**Next Steps**:
+1. Load `.tmp/external-context/react/hooks.md`
+2. Review current patterns for useState, useEffect, custom hooks
+3. Implement form following current best practices
+4. Use any new hooks introduced since training data
+
+---
+
+### Scenario 3: Express Middleware
+
+**You**: "I need to add JWT authentication middleware to Express"
+
+**Action**:
+```
+/external-scout express middleware - JWT authentication
+```
+
+**Result**: ExternalScout fetches current Express middleware patterns
+
+**Next Steps**:
+1. Load `.tmp/external-context/express/middleware.md`
+2. Review current middleware API and patterns
+3. Implement JWT middleware following current conventions
+4. Avoid deprecated middleware patterns
+
+---
+
+## Cache Management
+
+### Cache Freshness
+
+- **Fresh**: < 7 days old (use cached version)
+- **Stale**: > 7 days old (re-fetch from source)
+- **Missing**: No cache exists (fetch from source)
+
+### Cache Location
+
+```
+.tmp/external-context/
+├── drizzle/
+│ ├── .metadata.json
+│ ├── schemas.md
+│ └── queries.md
+├── react/
+│ ├── .metadata.json
+│ └── hooks.md
+└── express/
+ ├── .metadata.json
+ └── middleware.md
+```
+
+### Cache Cleanup
+
+Cache files are managed by the cleanup script:
+- External context older than 7 days is flagged for cleanup
+- Run cleanup script to review and remove old cache
+
+---
+
+## Configuration
+
+ExternalScout behavior can be configured via `.oac` config file:
+
+```yaml
+# External scout settings
+external_scout.enabled: true
+external_scout.cache_enabled: true
+external_scout.sources: context7
+```
+
+**Settings**:
+- `external_scout.enabled` - Enable/disable external documentation fetching
+- `external_scout.cache_enabled` - Enable/disable caching (always fetch if false)
+- `external_scout.sources` - Documentation sources to use (context7, web, etc.)
+
+---
+
+## What NOT to Do
+
+- ❌ **Don't skip external docs** — Always fetch current patterns for external packages
+- ❌ **Don't trust training data** — APIs change, training data is outdated
+- ❌ **Don't use stale cache** — If cache is > 7 days old, it will be re-fetched
+- ❌ **Don't implement before loading docs** — External docs first, code second
+- ❌ **Don't assume API patterns** — Verify with current documentation
+
+---
+
+## Troubleshooting
+
+### "External documentation fetch failed"
+
+**Cause**: Context7 API unavailable or network issue
+
+**Solution**:
+1. Check internet connection
+2. Try again in a few minutes
+3. Use fallback: Visit official documentation manually
+4. Cache will be created on next successful fetch
+
+### "Cache is stale, re-fetching"
+
+**Cause**: Cached documentation is > 7 days old
+
+**Solution**: This is normal behavior. ExternalScout will automatically fetch fresh docs.
+
+### "Package not found in Context7"
+
+**Cause**: Package may not be indexed in Context7 yet
+
+**Solution**:
+1. Visit official package documentation
+2. Check npm/PyPI for package README
+3. Review GitHub repository for API docs
+4. Manually create cache file if needed
+
+---
+
+## Principles
+
+- **Current docs matter** — Training data is outdated, always fetch current patterns
+- **Cache for performance** — Fetch once, use many times (within 7 days)
+- **Verify before implement** — Load external docs before writing code
+- **Trust the source** — Official docs > training data assumptions
+- **Fresh is better** — Re-fetch stale cache to get latest patterns
+
+---
+
+## Task
+
+Fetch external documentation for: **$ARGUMENTS**
+
+Check cache first, fetch if needed, and return file paths for loading.
diff --git a/plugins/claude-code/skills/parallel-execution/SKILL.md b/plugins/claude-code/skills/parallel-execution/SKILL.md
new file mode 100644
index 0000000..37c6bcc
--- /dev/null
+++ b/plugins/claude-code/skills/parallel-execution/SKILL.md
@@ -0,0 +1,484 @@
+---
+name: parallel-execution
+description: Execute multiple independent tasks in parallel using Claude Code's agent teams or multiple subagent invocations. Use when you have independent tasks with no dependencies, need to speed up multi-component features, or when task-manager marks tasks with parallel:true.
+---
+
+# Parallel Execution Skill
+
+Execute multiple independent tasks simultaneously to dramatically reduce implementation time for multi-component features.
+
+## When to Use This Skill
+
+Invoke parallel execution when:
+
+- **Multiple independent tasks** — Tasks with no shared files or dependencies
+- **Task-manager marks parallel:true** — TaskManager identified parallelizable work
+- **Multi-component features** — Frontend + backend + tests can run simultaneously
+- **Time-sensitive delivery** — Need to reduce total execution time
+- **Isolated work streams** — Different agents working on different areas
+- **Batch operations** — Converting multiple files, running multiple tests
+
+## When NOT to Use
+
+Avoid parallel execution when:
+
+- ❌ **Tasks modify the same files** — Will cause merge conflicts
+- ❌ **Tasks have dependencies** — One task needs output from another
+- ❌ **Shared state or resources** — Database migrations, global config changes
+- ❌ **Sequential logic required** — Steps must happen in specific order
+- ❌ **Single small task** — Overhead not worth it for simple operations
+
+## How Parallel Execution Works
+
+### Approach A: Multiple Subagent Invocations (Native)
+
+**Claude Code natively supports parallel work via multiple tool calls in one message.**
+
+When you make multiple independent `task()` calls in a single response, Claude Code executes them in parallel:
+
+```markdown
+I'll execute these three tasks in parallel:
+
+task(subagent_type="CoderAgent", description="Implement auth service", prompt="...")
+task(subagent_type="CoderAgent", description="Implement user service", prompt="...")
+task(subagent_type="TestEngineer", description="Create integration tests", prompt="...")
+```
+
+**Key points**:
+- All three tasks start simultaneously
+- Each runs in isolated context
+- Main agent waits for ALL to complete before proceeding
+- Results are collected and can be integrated
+
+### Approach B: Agent Teams (Experimental)
+
+**Requires**: `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=true`
+
+Agent teams allow multiple agents to collaborate on a shared workspace:
+
+```markdown
+I'll create an agent team for this feature:
+
+team(
+ name="auth-implementation",
+ agents=[
+ {type: "CoderAgent", task: "Backend auth service"},
+ {type: "OpenFrontendSpecialist", task: "Login UI components"},
+ {type: "TestEngineer", task: "E2E auth tests"}
+ ],
+ shared_context=".tmp/sessions/auth-context.md"
+)
+```
+
+**Key points**:
+- Agents share context file for coordination
+- Can communicate via shared state
+- More complex but enables tighter integration
+- Experimental feature, may change
+
+## Integration with Task-Manager
+
+TaskManager automatically identifies parallel tasks and marks them with `parallel: true`:
+
+### Task Structure Example
+
+**task.json**:
+```json
+{
+ "id": "user-dashboard",
+ "subtask_count": 5,
+ "context_files": [".opencode/context/core/standards/code-quality.md"]
+}
+```
+
+**subtask_01.json** (parallel):
+```json
+{
+ "id": "user-dashboard-01",
+ "seq": "01",
+ "title": "Create user profile API",
+ "parallel": true,
+ "depends_on": [],
+ "suggested_agent": "CoderAgent"
+}
+```
+
+**subtask_02.json** (parallel):
+```json
+{
+ "id": "user-dashboard-02",
+ "seq": "02",
+ "title": "Design dashboard UI components",
+ "parallel": true,
+ "depends_on": [],
+ "suggested_agent": "OpenFrontendSpecialist"
+}
+```
+
+**subtask_03.json** (sequential - depends on 01 and 02):
+```json
+{
+ "id": "user-dashboard-03",
+ "seq": "03",
+ "title": "Integrate API with UI",
+ "parallel": false,
+ "depends_on": ["01", "02"],
+ "suggested_agent": "CoderAgent"
+}
+```
+
+### Identifying Parallel Batches
+
+Use the task-management CLI to identify parallel tasks:
+
+```bash
+# Show which tasks can run in parallel
+bash .opencode/skills/task-management/router.sh parallel user-dashboard
+```
+
+**Output**:
+```
+Batch 1 (Ready now):
+- subtask_01.json (parallel: true)
+- subtask_02.json (parallel: true)
+
+Batch 2 (After Batch 1):
+- subtask_03.json (depends_on: ["01", "02"])
+```
+
+### Execution Workflow
+
+**Step 1: Analyze Task Structure**
+```markdown
+Read .tmp/tasks/{feature}/task.json
+Read all subtask_NN.json files
+Identify parallel batches using dependency graph
+```
+
+**Step 2: Execute Parallel Batch**
+```markdown
+For Batch 1 (subtasks 01 and 02 are parallel):
+
+task(
+ subagent_type="CoderAgent",
+ description="Execute subtask 01",
+ prompt="Read .tmp/tasks/user-dashboard/subtask_01.json and implement..."
+)
+
+task(
+ subagent_type="OpenFrontendSpecialist",
+ description="Execute subtask 02",
+ prompt="Read .tmp/tasks/user-dashboard/subtask_02.json and implement..."
+)
+
+Wait for both to complete...
+```
+
+**Step 3: Verify Batch Completion**
+```bash
+bash .opencode/skills/task-management/router.sh status user-dashboard
+```
+
+**Step 4: Execute Next Batch**
+```markdown
+Once Batch 1 is complete, proceed to Batch 2:
+
+task(
+ subagent_type="CoderAgent",
+ description="Execute subtask 03",
+ prompt="Read .tmp/tasks/user-dashboard/subtask_03.json and integrate..."
+)
+```
+
+## Practical Examples
+
+### Example 1: Converting Multiple Subagents in Parallel
+
+**Scenario**: Convert 5 subagent files from old format to new format
+
+```markdown
+I'll convert these subagents in parallel:
+
+task(subagent_type="CoderAgent", description="Convert auth-agent",
+ prompt="Convert .opencode/agent/subagents/auth-agent.md to new format...")
+
+task(subagent_type="CoderAgent", description="Convert user-agent",
+ prompt="Convert .opencode/agent/subagents/user-agent.md to new format...")
+
+task(subagent_type="CoderAgent", description="Convert payment-agent",
+ prompt="Convert .opencode/agent/subagents/payment-agent.md to new format...")
+
+task(subagent_type="CoderAgent", description="Convert notification-agent",
+ prompt="Convert .opencode/agent/subagents/notification-agent.md to new format...")
+
+task(subagent_type="CoderAgent", description="Convert analytics-agent",
+ prompt="Convert .opencode/agent/subagents/analytics-agent.md to new format...")
+```
+
+**Time savings**: 5 tasks × 10 min each = 50 min sequential → ~10 min parallel (80% faster)
+
+### Example 2: Running Tests in Parallel
+
+**Scenario**: Run unit tests, integration tests, and E2E tests simultaneously
+
+```markdown
+I'll run all test suites in parallel:
+
+task(subagent_type="TestEngineer", description="Run unit tests",
+ prompt="Execute unit test suite for src/auth/...")
+
+task(subagent_type="TestEngineer", description="Run integration tests",
+ prompt="Execute integration test suite for src/api/...")
+
+task(subagent_type="TestEngineer", description="Run E2E tests",
+ prompt="Execute E2E test suite for user flows...")
+```
+
+**Time savings**: 3 suites × 5 min each = 15 min sequential → ~5 min parallel (67% faster)
+
+### Example 3: Implementing Independent Features
+
+**Scenario**: Build authentication system with parallel work streams
+
+```markdown
+I'll implement these independent components in parallel:
+
+task(subagent_type="CoderAgent", description="JWT service",
+ prompt="Create JWT token generation and validation service...")
+
+task(subagent_type="CoderAgent", description="Password hashing",
+ prompt="Implement bcrypt password hashing utilities...")
+
+task(subagent_type="CoderAgent", description="Session storage",
+ prompt="Create Redis-based session storage layer...")
+
+task(subagent_type="OpenFrontendSpecialist", description="Login UI",
+ prompt="Design and implement login form components...")
+```
+
+**Time savings**: 4 components × 30 min each = 120 min sequential → ~30 min parallel (75% faster)
+
+## Best Practices
+
+### 1. Avoid File Conflicts
+
+**✅ Good** (isolated files):
+```markdown
+task(CoderAgent, "Create src/auth/service.ts")
+task(CoderAgent, "Create src/user/service.ts")
+task(CoderAgent, "Create src/payment/service.ts")
+```
+
+**❌ Bad** (same file):
+```markdown
+task(CoderAgent, "Add auth function to src/utils/helpers.ts")
+task(CoderAgent, "Add validation function to src/utils/helpers.ts")
+```
+
+### 2. Size Tasks Appropriately
+
+**✅ Good** (balanced tasks):
+```markdown
+task(CoderAgent, "Implement user CRUD API (30 min)")
+task(CoderAgent, "Implement auth middleware (30 min)")
+```
+
+**❌ Bad** (unbalanced):
+```markdown
+task(CoderAgent, "Implement entire backend (2 hours)")
+task(CoderAgent, "Add one import statement (1 min)")
+```
+
+### 3. Monitor Progress
+
+After delegating parallel tasks, track completion:
+
+```bash
+# Check status periodically
+bash .opencode/skills/task-management/router.sh status {feature}
+
+# Look for:
+# - subtask_01.json: status: "completed" ✓
+# - subtask_02.json: status: "completed" ✓
+# - subtask_03.json: status: "in_progress" ...
+```
+
+### 4. Handle Failures Gracefully
+
+If one parallel task fails:
+
+```markdown
+Batch 1 Results:
+- Task 01: ✅ Completed
+- Task 02: ❌ Failed (missing dependency)
+- Task 03: ✅ Completed
+
+Action: Fix Task 02 before proceeding to Batch 2
+```
+
+### 5. Coordinate Shared Context
+
+When tasks need shared information:
+
+**✅ Good** (pre-load context):
+```markdown
+# Load context BEFORE parallel execution
+Read .opencode/context/core/standards/code-quality.md
+Read .opencode/context/core/standards/security-patterns.md
+
+# Now all parallel tasks have same context
+task(CoderAgent, "Implement auth service...")
+task(CoderAgent, "Implement user service...")
+```
+
+**❌ Bad** (each task discovers context):
+```markdown
+# Each task will call ContextScout separately (slower)
+task(CoderAgent, "Discover context and implement auth...")
+task(CoderAgent, "Discover context and implement user...")
+```
+
+## Troubleshooting
+
+### Issue: Tasks completing out of order
+
+**Problem**: Task 02 finishes before Task 01, but Task 03 depends on both
+
+**Solution**: Use dependency tracking in subtask JSON:
+```json
+{
+ "id": "feature-03",
+ "depends_on": ["01", "02"],
+ "parallel": false
+}
+```
+
+Don't start Task 03 until BOTH 01 and 02 are marked `status: "completed"`.
+
+### Issue: File conflicts during parallel execution
+
+**Problem**: Two tasks tried to modify the same file
+
+**Solution**:
+1. Review task breakdown - ensure true isolation
+2. If tasks MUST touch same file, mark `parallel: false`
+3. Sequence dependent tasks properly
+
+### Issue: One task blocked waiting for another
+
+**Problem**: Task 01 needs output from Task 02, but both marked parallel
+
+**Solution**: Fix dependency graph:
+```json
+{
+ "id": "feature-01",
+ "depends_on": ["02"], // Add dependency
+ "parallel": false // Mark sequential
+}
+```
+
+### Issue: Parallel tasks not actually running in parallel
+
+**Problem**: Tasks executing sequentially despite parallel flags
+
+**Solution**: Ensure you're making multiple `task()` calls in SAME message:
+
+**✅ Correct**:
+```markdown
+I'll execute these in parallel:
+
+task(...)
+task(...)
+task(...)
+```
+
+**❌ Wrong** (sequential):
+```markdown
+I'll execute task 1:
+task(...)
+
+[Wait for response]
+
+Now I'll execute task 2:
+task(...)
+```
+
+## Performance Impact
+
+### Time Savings by Parallelization
+
+| Scenario | Sequential | Parallel | Savings |
+|----------|-----------|----------|---------|
+| 3 independent components (30 min each) | 90 min | 30 min | 67% |
+| 5 file conversions (10 min each) | 50 min | 10 min | 80% |
+| 4 test suites (15 min each) | 60 min | 15 min | 75% |
+| Frontend + Backend + Tests | 120 min | 40 min | 67% |
+
+### Optimal Batch Sizes
+
+- **2-4 tasks**: Ideal for most scenarios
+- **5-8 tasks**: Good if truly independent
+- **9+ tasks**: Consider breaking into multiple batches
+
+## Related Skills
+
+- `/task-breakdown` — Creates task structure with parallel flags
+- `/context-discovery` — Load shared context before parallel execution
+- `/code-review` — Review all parallel outputs together
+
+## Advanced: Agent Teams
+
+For complex features requiring tight coordination, use agent teams (experimental):
+
+```markdown
+team(
+ name="e-commerce-checkout",
+ agents=[
+ {
+ type: "CoderAgent",
+ role: "backend",
+ tasks: ["Payment API", "Order processing", "Inventory check"]
+ },
+ {
+ type: "OpenFrontendSpecialist",
+ role: "frontend",
+ tasks: ["Checkout UI", "Payment form", "Order confirmation"]
+ },
+ {
+ type: "TestEngineer",
+ role: "qa",
+ tasks: ["Integration tests", "E2E checkout flow"]
+ }
+ ],
+ shared_context: ".tmp/sessions/checkout-context.md",
+ coordination: "async" // Agents coordinate via shared context file
+)
+```
+
+**Benefits**:
+- Agents can update shared context as they progress
+- Enables async coordination without blocking
+- Better for complex features with evolving requirements
+
+**Drawbacks**:
+- Experimental feature
+- More complex to debug
+- Requires careful context management
+
+---
+
+## Summary
+
+Parallel execution is a powerful technique for reducing implementation time when:
+1. Tasks are truly independent (no shared files/state)
+2. TaskManager marks tasks with `parallel: true`
+3. You make multiple `task()` calls in same message
+
+**Key takeaways**:
+- ✅ Use for independent components, file conversions, test suites
+- ✅ Pre-load shared context before parallel execution
+- ✅ Monitor completion with task-management CLI
+- ❌ Avoid for tasks with dependencies or shared files
+- ❌ Don't parallelize tasks that modify same file
+
+**Time savings**: 50-80% reduction in execution time for multi-component features.
diff --git a/plugins/claude-code/skills/task-breakdown/SKILL.md b/plugins/claude-code/skills/task-breakdown/SKILL.md
new file mode 100644
index 0000000..0116b34
--- /dev/null
+++ b/plugins/claude-code/skills/task-breakdown/SKILL.md
@@ -0,0 +1,154 @@
+---
+name: task-breakdown
+description: Break down complex features into atomic, verifiable subtasks with dependency tracking. Use when implementing multi-step workflows, complex features requiring multiple files, or when the user requests task planning.
+context: fork
+agent: task-manager
+---
+
+# Task Breakdown
+
+Break down this feature into atomic, verifiable subtasks: $ARGUMENTS
+
+## Your Task
+
+Create a structured task breakdown following the JSON schema:
+
+1. **Analyze the feature**:
+ - Identify core objective and scope
+ - Determine technical risks and dependencies
+ - Find natural task boundaries
+ - Identify which tasks can run in parallel
+
+2. **Create task plan**:
+ - Feature ID (kebab-case)
+ - Objective (max 200 chars)
+ - Context files (standards to follow)
+ - Reference files (source material to study)
+ - Exit criteria (completion requirements)
+
+3. **Generate subtasks**:
+ - Sequential numbering (01, 02, 03...)
+ - Clear title for each
+ - Dependencies mapped via `depends_on`
+ - Parallel flags set for isolated tasks
+ - Suggested agent assigned
+ - Acceptance criteria (binary pass/fail)
+ - Deliverables (specific file paths or endpoints)
+
+4. **Create JSON files**:
+ - `.tmp/tasks/{feature}/task.json` - Feature metadata
+ - `.tmp/tasks/{feature}/subtask_01.json` - First subtask
+ - `.tmp/tasks/{feature}/subtask_02.json` - Second subtask
+ - ... (one file per subtask)
+
+5. **Validate structure**:
+ - All JSON files are valid
+ - Dependency references exist
+ - Context files vs reference files are separated
+ - Acceptance criteria are binary
+ - Deliverables are specific
+
+## Critical Rules
+
+- **Atomic tasks**: Each subtask completable in 1-2 hours
+- **Context separation**:
+ - `context_files` = standards/conventions ONLY
+ - `reference_files` = project source files ONLY
+ - Never mix them
+- **Binary criteria**: Pass/fail only, no ambiguity
+- **Parallel identification**: Mark isolated tasks as `parallel: true`
+- **Agent assignment**: Suggest appropriate agent for each subtask
+ - "CoderAgent" - Implementation tasks
+ - "TestEngineer" - Test creation
+ - "CodeReviewer" - Review tasks
+ - "OpenFrontendSpecialist" - UI/design tasks
+
+## When to Use This Skill
+
+Use task-breakdown when:
+- Feature requires multiple files or components
+- Implementation has clear sequential steps
+- Tasks have dependencies that need tracking
+- Work can be parallelized across isolated areas
+- User explicitly requests task planning
+- Feature is complex enough to benefit from structured breakdown
+
+## Output Format
+
+Return a summary:
+```
+## Tasks Created
+
+Location: .tmp/tasks/{feature}/
+Files: task.json + {N} subtasks
+
+Subtasks:
+- 01: {title} (parallel: {true/false}, agent: {suggested_agent})
+- 02: {title} (parallel: {true/false}, agent: {suggested_agent})
+...
+
+Next Steps:
+- Execute subtasks in order
+- Parallel tasks can run simultaneously
+- Use task-cli.ts for status tracking
+```
+
+## Example Task Structure
+
+**task.json**:
+```json
+{
+ "id": "jwt-auth",
+ "name": "JWT Authentication System",
+ "status": "active",
+ "objective": "Implement JWT-based authentication with refresh tokens",
+ "context_files": [
+ ".opencode/context/core/standards/code-quality.md",
+ ".opencode/context/core/standards/security-patterns.md"
+ ],
+ "reference_files": [
+ "src/middleware/auth.middleware.ts"
+ ],
+ "exit_criteria": [
+ "All tests passing",
+ "JWT tokens signed with RS256"
+ ],
+ "subtask_count": 3,
+ "completed_count": 0,
+ "created_at": "2026-02-16T02:00:00Z"
+}
+```
+
+**subtask_01.json**:
+```json
+{
+ "id": "jwt-auth-01",
+ "seq": "01",
+ "title": "Create JWT service with token generation",
+ "status": "pending",
+ "depends_on": [],
+ "parallel": true,
+ "suggested_agent": "CoderAgent",
+ "context_files": [
+ ".opencode/context/core/standards/security-patterns.md"
+ ],
+ "reference_files": [],
+ "acceptance_criteria": [
+ "JWT tokens signed with RS256 algorithm",
+ "Access tokens expire in 15 minutes"
+ ],
+ "deliverables": [
+ "src/auth/jwt.service.ts",
+ "src/auth/jwt.service.test.ts"
+ ]
+}
+```
+
+## Quality Standards
+
+- Clear objectives: Single, measurable outcome per task
+- Explicit deliverables: Specific files or endpoints
+- Context references: Reference paths, don't embed content
+- Summary length: Max 200 characters for completion_summary
+- Dependency tracking: Explicit `depends_on` arrays
+- Parallelization: Mark isolated tasks for concurrent execution
diff --git a/plugins/claude-code/skills/test-generation/SKILL.md b/plugins/claude-code/skills/test-generation/SKILL.md
new file mode 100644
index 0000000..e31c0b4
--- /dev/null
+++ b/plugins/claude-code/skills/test-generation/SKILL.md
@@ -0,0 +1,399 @@
+---
+name: test-generation
+description: Generate comprehensive tests following TDD principles. Use when writing tests for new features, implementing TDD workflows, or adding test coverage to existing code.
+context: fork
+agent: test-engineer
+---
+
+# Test Generation
+
+Generate comprehensive tests following TDD principles and project testing standards.
+
+## When to Use This Skill
+
+Invoke this skill when:
+- **After implementation**: Writing tests for newly implemented features
+- **TDD workflow**: Writing tests before implementation (test-first development)
+- **Coverage gaps**: Adding tests to existing code that lacks coverage
+- **Regression testing**: Adding tests to prevent bugs from reoccurring
+- **Refactoring**: Ensuring behavior is preserved during code changes
+
+## How It Works
+
+This skill runs in the **test-engineer** subagent with an isolated context. The main agent must:
+
+1. **Pre-load testing standards** before invoking this skill
+2. **Specify test requirements** clearly
+3. **Review the test plan** before implementation
+4. **Receive test results** and integrate them into the workflow
+
+## Usage Pattern
+
+### Step 1: Load Testing Context (Main Agent)
+
+Before invoking this skill, load project testing standards:
+
+```markdown
+Read these files to understand testing requirements:
+- .opencode/context/core/standards/tests.md
+- .opencode/context/core/standards/test-coverage.md
+- [project-specific test conventions]
+```
+
+### Step 2: Invoke Test Generation
+
+Use this skill with clear requirements:
+
+```markdown
+/test-generation
+
+Generate tests for [feature/component]:
+
+**Feature**: [Brief description]
+
+**Acceptance Criteria**:
+- [Criterion 1]
+- [Criterion 2]
+- [Criterion 3]
+
+**Behaviors to Test**:
+1. [Behavior 1] - [expected outcome]
+2. [Behavior 2] - [expected outcome]
+3. [Error handling for X]
+
+**Coverage Requirements**:
+- Line coverage: [X]%
+- Branch coverage: [X]%
+- All critical paths tested
+
+**Testing Standards** (pre-loaded):
+- Test framework: [vitest/jest/pytest/etc.]
+- Assertion library: [expect/chai/etc.]
+- Mock library: [vi/jest.mock/etc.]
+- File naming: [*.test.ts / *.spec.ts / test_*.py]
+- Test structure: [AAA pattern required]
+```
+
+### Step 3: Review Test Plan
+
+The test-engineer will propose a test plan:
+
+```markdown
+## Test Plan for [Feature]
+
+### Behaviors to Test
+1. [Behavior 1]
+ - ✅ Positive: [success case]
+ - ❌ Negative: [failure/edge case]
+2. [Behavior 2]
+ - ✅ Positive: [success case]
+ - ❌ Negative: [failure/edge case]
+
+### Mocking Strategy
+- [External dependency 1]: Mock with [approach]
+- [External dependency 2]: Mock with [approach]
+
+### Coverage Target
+- [X]% line coverage
+- All critical paths tested
+```
+
+**IMPORTANT**: Review and approve the test plan before implementation proceeds.
+
+### Step 4: Receive Test Results
+
+After implementation, the test-engineer returns:
+
+```yaml
+status: "success" | "failure"
+tests_written: [number]
+coverage:
+ lines: [percentage]
+ branches: [percentage]
+ functions: [percentage]
+behaviors_tested:
+ - name: "[Behavior 1]"
+ positive_tests: [count]
+ negative_tests: [count]
+test_results:
+ passed: [count]
+ failed: [count]
+self_review:
+ positive_negative_coverage: "✅ pass"
+ aaa_pattern: "✅ pass"
+ determinism: "✅ pass"
+ code_quality: "✅ pass"
+ standards_compliance: "✅ pass"
+deliverables:
+ - "[path/to/test/file.test.ts]"
+```
+
+## Test Requirements Specification
+
+### Minimal Requirements
+
+At minimum, specify:
+- **What to test**: Feature/component name and behaviors
+- **Acceptance criteria**: What defines success
+- **Coverage target**: Percentage or "all critical paths"
+
+### Recommended Requirements
+
+For best results, also specify:
+- **Test framework**: vitest, jest, pytest, etc.
+- **Mock patterns**: How to handle external dependencies
+- **Edge cases**: Specific scenarios to cover
+- **Error conditions**: Expected failure modes
+
+### Example: Simple Feature
+
+```markdown
+/test-generation
+
+Generate tests for user authentication:
+
+**Feature**: JWT token validation middleware
+
+**Behaviors**:
+1. Valid token → allow request
+2. Expired token → reject with 401
+3. Invalid signature → reject with 401
+4. Missing token → reject with 401
+
+**Coverage**: All critical paths
+```
+
+### Example: Complex Feature
+
+```markdown
+/test-generation
+
+Generate tests for payment processing service:
+
+**Feature**: Stripe payment integration
+
+**Acceptance Criteria**:
+- Process successful payments
+- Handle declined cards gracefully
+- Retry failed network requests (max 3 attempts)
+- Log all payment attempts
+- Emit payment events for webhooks
+
+**Behaviors to Test**:
+1. Successful payment flow
+2. Declined card handling
+3. Network retry logic
+4. Idempotency (duplicate requests)
+5. Webhook event emission
+
+**External Dependencies** (must be mocked):
+- Stripe API calls
+- Database writes
+- Event emitter
+- Logger
+
+**Coverage Requirements**:
+- Line coverage: 90%+
+- All error paths tested
+- All retry scenarios tested
+
+**Testing Standards**:
+- Framework: vitest
+- Mocks: vi.mock()
+- Assertions: expect()
+- Structure: AAA pattern
+```
+
+## TDD Workflow
+
+For test-driven development, invoke this skill **before** implementation:
+
+### Step 1: Write Tests First
+
+```markdown
+/test-generation
+
+Write tests for [feature] following TDD:
+
+**Feature**: [Description]
+
+**Expected Behavior**:
+- [Behavior 1]
+- [Behavior 2]
+
+**Note**: Implementation does not exist yet. Write tests that define the expected behavior.
+```
+
+### Step 2: Verify Tests Fail
+
+The test-engineer will write tests and verify they fail (since implementation doesn't exist).
+
+### Step 3: Implement Feature
+
+Use the failing tests as a specification to guide implementation.
+
+### Step 4: Verify Tests Pass
+
+After implementation, run tests to confirm they pass.
+
+## What the Test-Engineer Does
+
+The test-engineer subagent will:
+
+1. ✅ **Review pre-loaded testing standards** (provided by main agent)
+2. ✅ **Propose a test plan** with positive and negative cases
+3. ✅ **Request approval** before implementing tests
+4. ✅ **Implement tests** following AAA pattern (Arrange-Act-Assert)
+5. ✅ **Mock all external dependencies** (network, time, file system)
+6. ✅ **Run tests** and verify they pass
+7. ✅ **Self-review** for quality and standards compliance
+8. ✅ **Return structured results** to main agent
+
+## What the Test-Engineer Does NOT Do
+
+The test-engineer will NOT:
+
+- ❌ Request additional context (main agent pre-loads standards)
+- ❌ Call other subagents (returns results to main agent)
+- ❌ Skip negative tests (both positive and negative required)
+- ❌ Use real network calls (all external deps mocked)
+- ❌ Leave flaky tests (deterministic only)
+
+## Integration with OAC Workflow
+
+### Stage 4: Execute (After Implementation)
+
+```markdown
+1. Implement feature using /code-execution skill
+2. Generate tests using /test-generation skill
+3. Verify tests pass
+4. Proceed to Stage 5: Validate
+```
+
+### Stage 5: Validate (Test Execution)
+
+```markdown
+1. Run test suite
+2. Verify coverage meets requirements
+3. If tests fail → return to Stage 4
+4. If tests pass → proceed to Stage 6
+```
+
+## Common Patterns
+
+### Pattern 1: Post-Implementation Testing
+
+```markdown
+# After implementing a feature
+/test-generation
+
+Generate tests for the authentication service implemented in src/auth/service.ts:
+
+**Behaviors**: [list from acceptance criteria]
+**Coverage**: 90%+
+```
+
+### Pattern 2: TDD (Test-First)
+
+```markdown
+# Before implementing a feature
+/test-generation
+
+Write tests for a new user registration endpoint (not yet implemented):
+
+**Expected Behavior**:
+- POST /api/register with valid data → 201 + user object
+- POST /api/register with duplicate email → 409 error
+- POST /api/register with invalid email → 400 error
+
+**Note**: Implementation does not exist. Write tests that define expected behavior.
+```
+
+### Pattern 3: Regression Testing
+
+```markdown
+# After fixing a bug
+/test-generation
+
+Add regression tests for bug #123 (user session expiry):
+
+**Bug**: Sessions not expiring after 24 hours
+**Fix**: Added TTL check in session middleware
+**Test**: Verify sessions expire correctly after 24 hours (use fake timers)
+```
+
+### Pattern 4: Refactoring Safety
+
+```markdown
+# Before refactoring
+/test-generation
+
+Generate comprehensive tests for the payment service before refactoring:
+
+**Purpose**: Ensure behavior is preserved during refactoring
+**Coverage**: 100% of current behavior
+**Focus**: All public API methods and edge cases
+```
+
+## Tips for Success
+
+1. **Pre-load context**: Always load testing standards before invoking this skill
+2. **Be specific**: Clear requirements = better tests
+3. **Review test plans**: Approve before implementation to catch gaps early
+4. **Specify mocks**: Tell the test-engineer what external dependencies exist
+5. **Define coverage**: Set clear coverage targets (percentage or "all critical paths")
+6. **Use TDD**: Write tests first when possible — they guide better design
+
+## Troubleshooting
+
+### Issue: Tests don't match project conventions
+
+**Solution**: Ensure testing standards are pre-loaded before invoking this skill:
+```markdown
+Read .opencode/context/core/standards/tests.md before generating tests.
+```
+
+### Issue: Missing edge cases
+
+**Solution**: Specify edge cases explicitly in the requirements:
+```markdown
+**Edge Cases to Test**:
+- Empty input
+- Null values
+- Extremely large inputs
+- Concurrent requests
+```
+
+### Issue: Flaky tests
+
+**Solution**: Specify that external dependencies must be mocked:
+```markdown
+**External Dependencies** (must be mocked):
+- API calls to [service]
+- Database queries
+- Current time (use fake timers)
+```
+
+### Issue: Insufficient coverage
+
+**Solution**: Set explicit coverage targets:
+```markdown
+**Coverage Requirements**:
+- Line coverage: 90%+
+- Branch coverage: 85%+
+- All error paths tested
+```
+
+---
+
+## Related Skills
+
+- `/code-execution` - Implement features before testing
+- `/code-review` - Review test quality and coverage
+- `/context-discovery` - Find testing standards and conventions
+
+## Related Context
+
+- `.opencode/context/core/standards/tests.md` - Testing standards
+- `.opencode/context/core/standards/test-coverage.md` - Coverage requirements
+- `.opencode/context/core/workflows/review.md` - Test review workflow
diff --git a/plugins/claude-code/skills/using-oac/SKILL.md b/plugins/claude-code/skills/using-oac/SKILL.md
new file mode 100644
index 0000000..4792b30
--- /dev/null
+++ b/plugins/claude-code/skills/using-oac/SKILL.md
@@ -0,0 +1,327 @@
+---
+name: using-oac
+description: OpenAgents Control workflow for context-aware development. Auto-invokes on every task to ensure proper context discovery, planning, and execution with approval gates.
+---
+
+# OpenAgents Control (OAC) Workflow
+
+**Purpose**: Guide Claude through context-aware development using the 6-stage OAC workflow.
+
+**When to use**: Automatically invoked for every development task to ensure proper context discovery, planning, and validation.
+
+---
+
+## 6-Stage Workflow
+
+Execute these stages in order for every development task:
+
+### Stage 1: Analyze & Discover
+
+**Goal**: Understand the task and discover relevant context files.
+
+**Actions**:
+1. Analyze the user's request to understand:
+ - What they want to build/change
+ - Technical scope and complexity
+ - Potential risks or dependencies
+
+2. Invoke the `/context-discovery` skill to find relevant context files:
+ - Coding standards and conventions
+ - Architecture patterns
+ - Security guidelines
+ - Domain-specific guides
+
+3. Capture the list of context files returned by ContextScout
+
+**Output**: List of context files to load, understanding of task scope
+
+---
+
+### Stage 2: Plan & Approve
+
+**Goal**: Create an execution plan and get user approval before proceeding.
+
+**Actions**:
+1. Based on task complexity, create a plan:
+
+ **Simple tasks** (1-3 files, <30 min):
+ - Direct implementation approach
+ - List of files to create/modify
+ - Key technical decisions
+
+ **Complex tasks** (4+ files, >30 min):
+ - High-level breakdown into phases
+ - Dependencies between components
+ - Suggest using `/task-breakdown` skill for detailed subtasks
+
+2. Present the plan to the user with:
+ - Summary of approach
+ - Files that will be created/modified
+ - Context files that will be loaded
+ - Estimated complexity
+
+3. **REQUEST APPROVAL** - Wait for user confirmation before proceeding
+
+**Critical**: NEVER proceed to Stage 3 without explicit user approval.
+
+**Output**: Approved execution plan
+
+---
+
+### Stage 3: LoadContext
+
+**Goal**: Pre-load ALL discovered context files so they're available during execution.
+
+**Actions**:
+1. Read EVERY context file discovered in Stage 1:
+ - Use the `Read` tool to load each file
+ - Load files in priority order (Critical → High → Medium)
+ - **Example**: If Stage 1 found 5 files, Stage 3 reads all 5
+ - **Important**: Don't skip any files - load everything discovered
+
+2. Internalize the loaded context:
+ - Coding standards and patterns
+ - Security requirements
+ - Naming conventions
+ - Architecture constraints
+ - Project-specific conventions
+
+**Why This Matters**: This stage prevents nested ContextScout calls during execution. By loading ALL context upfront, subagents invoked in Stage 4 can use the pre-loaded context without needing to call ContextScout themselves. This maintains the flattened delegation hierarchy required by Claude Code.
+
+3. If external libraries are involved, invoke `/external-scout` to fetch current API docs:
+ - **Example**: If using Drizzle ORM → `/external-scout drizzle schemas`
+ - **Example**: If using React hooks → `/external-scout react hooks`
+ - Load the cached documentation files returned by ExternalScout
+ - Apply current API patterns from external docs
+
+**Output**: All context loaded (internal + external) and ready for execution
+
+---
+
+### Stage 4: Execute
+
+**Goal**: Implement the solution following loaded context and standards.
+
+**Actions**:
+
+**For Simple Tasks** (direct execution):
+1. Implement the solution directly:
+ - Follow coding standards from loaded context
+ - Apply security patterns
+ - Use naming conventions
+ - Create tests if required
+
+2. Self-review before completion:
+ - Verify all acceptance criteria met
+ - Check for type errors or missing imports
+ - Scan for debug artifacts (console.log, TODO, etc.)
+ - Validate against loaded standards
+
+**For Complex Tasks** (delegated execution):
+1. Invoke `/task-breakdown` skill to create detailed subtasks:
+ - TaskManager will create JSON task files
+ - Each subtask will have clear acceptance criteria
+ - Dependencies will be mapped
+
+2. Execute subtasks in order:
+ - Use `/code-execution` skill for implementation subtasks
+ - Use `/test-generation` skill for test subtasks
+ - Use `/code-review` skill for review subtasks
+
+3. Track progress through subtask completion
+
+**Output**: Implementation complete, all deliverables created
+
+---
+
+### Stage 5: Validate
+
+**Goal**: Verify the implementation works correctly.
+
+**Actions**:
+1. Run tests (if they exist):
+ - Execute test suite
+ - Check for failures
+ - Verify coverage meets requirements
+
+2. Validate against acceptance criteria:
+ - Check each criterion from the plan
+ - Verify all deliverables exist
+ - Confirm standards were followed
+
+3. **STOP on failure**:
+ - If tests fail → fix issues before proceeding
+ - If criteria unmet → complete implementation
+ - If standards violated → refactor to comply
+
+**Critical**: Do not proceed to Stage 6 if validation fails.
+
+**Output**: Validated, working implementation
+
+---
+
+### Stage 6: Complete
+
+**Goal**: Finalize the task with documentation and cleanup.
+
+**Actions**:
+1. Update documentation (if needed):
+ - Update README if new features added
+ - Add inline documentation for complex logic
+ - Update API docs if endpoints changed
+
+2. Summarize what was done:
+ - List files created/modified
+ - Highlight key technical decisions
+ - Note any follow-up tasks needed
+
+3. Cleanup (if applicable):
+ - Remove temporary files
+ - Clean up debug code
+ - Archive session files (for complex tasks)
+
+4. Present completion summary to user
+
+**Output**: Task complete, documented, and summarized
+
+---
+
+## Key Principles
+
+### Flat Delegation Hierarchy
+
+**OAC Pattern** (nested - NOT supported in Claude Code):
+```
+Main Agent → TaskManager → CoderAgent → ContextScout
+```
+
+**Claude Code Pattern** (flat - CORRECT):
+```
+Main Agent → ContextScout (via /context-discovery)
+Main Agent → TaskManager (via /task-breakdown)
+Main Agent → CoderAgent (via /code-execution)
+```
+
+**Rule**: Only the main agent can invoke subagents. Subagents cannot call other subagents.
+
+### Context Pre-Loading
+
+**Why**: Prevents nested ContextScout calls during execution.
+
+**How**: Stage 3 loads ALL context upfront, so execution stages (4-6) have everything they need.
+
+### Approval Gates
+
+**Critical checkpoints**:
+- **Stage 2 → Stage 3**: User must approve the plan
+- **Stage 5 → Stage 6**: Validation must pass
+
+**Never skip approval** - it prevents wasted work and ensures alignment.
+
+### Progressive Complexity
+
+**Simple tasks**: Stages 1-2-3-4-5-6 executed inline by main agent
+
+**Complex tasks**: Stages 1-2-3 by main agent, Stage 4 delegated to TaskManager + specialists
+
+---
+
+## Skill Invocations
+
+Use these skills at the appropriate stages:
+
+| Skill | When to Invoke | Purpose |
+|-------|----------------|---------|
+| `/context-discovery` | Stage 1 | Find relevant context files |
+| `/external-scout` | Stage 3 | Fetch external library documentation |
+| `/task-breakdown` | Stage 4 (complex tasks) | Create detailed subtasks |
+| `/code-execution` | Stage 4 (subtasks) | Implement code subtasks |
+| `/test-generation` | Stage 4 (subtasks) | Create test subtasks |
+| `/code-review` | Stage 4 (subtasks) | Review code subtasks |
+
+---
+
+## Example Workflow
+
+### Simple Task: "Add email validation to user registration"
+
+**Stage 1**: Analyze → Invoke `/context-discovery` → Get validation patterns, security standards
+
+**Stage 2**: Plan → "Add email regex validation to registration endpoint" → Request approval
+
+**Stage 3**: Load context → Read validation patterns, security standards
+
+**Stage 4**: Execute → Implement validation, add tests, self-review
+
+**Stage 5**: Validate → Run tests, verify criteria met
+
+**Stage 6**: Complete → Update API docs, summarize changes
+
+### Complex Task: "Build user authentication system"
+
+**Stage 1**: Analyze → Invoke `/context-discovery` → Get auth patterns, security standards, architecture guides
+
+**Stage 2**: Plan → "Multi-phase: JWT service, middleware, endpoints, tests" → Request approval
+
+**Stage 3**: Load context → Read all discovered context files
+
+**Stage 4**: Execute → Invoke `/task-breakdown` → TaskManager creates subtasks → Execute subtasks using `/code-execution`, `/test-generation`, `/code-review`
+
+**Stage 5**: Validate → Run full test suite, verify all acceptance criteria
+
+**Stage 6**: Complete → Update docs, summarize implementation, archive session
+
+---
+
+## Anti-Patterns to Avoid
+
+❌ **Skipping Stage 1** - Coding without context discovery leads to inconsistent patterns
+
+❌ **Skipping Stage 2 approval** - Implementing without user buy-in wastes effort
+
+❌ **Nested subagent calls** - Subagents calling other subagents (not supported in Claude Code)
+
+❌ **Context discovery during execution** - Should be done in Stage 1, loaded in Stage 3
+
+❌ **Proceeding with failed validation** - Stage 5 failures must be fixed before Stage 6
+
+---
+
+## Session Management (Complex Tasks)
+
+For complex tasks requiring TaskManager delegation:
+
+**Session Location**: `.tmp/sessions/{YYYY-MM-DD}-{task-slug}/`
+
+**Session Files**:
+- `context.md` - Task context, discovered files, requirements
+- `progress.md` - Execution progress tracking
+
+**Cleanup**: After Stage 6, ask user if session files should be deleted
+
+---
+
+## Related Skills
+
+- `context-discovery` - Stage 1 context discovery
+- `external-scout` - Stage 3 external library documentation
+- `task-breakdown` - Stage 4 complex task delegation
+- `code-execution` - Stage 4 code implementation
+- `test-generation` - Stage 4 test creation
+- `code-review` - Stage 4 code review
+
+---
+
+## Success Criteria
+
+✅ Every task follows all 6 stages in order
+
+✅ Context discovered before execution
+
+✅ User approval obtained before implementation
+
+✅ All context pre-loaded (no nested discovery)
+
+✅ Validation passes before completion
+
+✅ Documentation updated and task summarized