diff --git a/.npmignore b/.npmignore
new file mode 100644
index 0000000..62980c1
--- /dev/null
+++ b/.npmignore
@@ -0,0 +1,86 @@
+# Development files
+.git/
+.github/
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Environment and secrets
+.env
+.env.*
+!.env.example
+env.example
+
+# Dependencies
+node_modules/
+**/node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+bun.lock
+package-lock.json
+
+# Exclude tool directory (large binaries)
+.opencode/tool/
+**/.opencode/tool/
+
+# Build and test artifacts
+dist/
+build/
+out/
+coverage/
+.nyc_output/
+*.tsbuildinfo
+
+# Temporary files
+.tmp/
+tmp/
+temp/
+*.log
+
+# OS files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Development and testing
+evals/
+dev/
+tasks/
+integrations/
+packages/
+
+# Test and development scripts
+Makefile
+.gitignore
+.gitattributes
+
+# Documentation that's not needed in package
+docs/
+ROADMAP.md
+COMPATIBILITY.md
+
+# Backup files
+*.backup-*/
+.opencode.backup-*
+.opencode-test/
+.opencode-agents-version
+
+# Keep these (explicitly included in package.json files field)
+!.opencode/
+!scripts/
+!bin/
+!registry.json
+!install.sh
+!VERSION
+!LICENSE
+!README.md
+!CHANGELOG.md
+!CONTEXT_SYSTEM_GUIDE.md
diff --git a/.opencode/_lib/telegram-bot.ts b/.opencode/_lib/telegram-bot.ts
deleted file mode 100644
index f71c161..0000000
--- a/.opencode/_lib/telegram-bot.ts
+++ /dev/null
@@ -1,234 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Simple Telegram Bot for OpenCode
- * Sends notifications when session becomes idle
- */
-
-import https from 'https'
-import fs from 'fs'
-import path from 'path'
-import { fileURLToPath } from 'url'
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-
-class SimpleTelegramBot {
-  private botToken: string | undefined
-  private chatId: string | undefined
-  private botUsername: string
-  private idleTimeout: number
-  private checkInterval: number
-  private lastActivity: number
-  private idleTimer: NodeJS.Timeout | null
-  private checkTimer: NodeJS.Timeout | null
-  private isIdle: boolean
-
-  constructor() {
-    this.loadEnvFile();
-    this.botToken = process.env.TELEGRAM_BOT_TOKEN;
-    this.chatId = process.env.TELEGRAM_CHAT_ID;
-    this.botUsername = process.env.TELEGRAM_BOT_USERNAME || '@OpenCode';
-    this.idleTimeout = parseInt(process.env.TELEGRAM_IDLE_TIMEOUT || '300000'); // 5 minutes default
-    this.checkInterval = parseInt(process.env.TELEGRAM_CHECK_INTERVAL || '30000'); // 30 seconds default
-    
-    this.lastActivity = Date.now();
-    this.idleTimer = null;
-    this.checkTimer = null;
-    this.isIdle = false;
-    
-    this.validateConfig();
-  }
-
-  /**
-   * Load environment variables from .env file
-   */
-  private loadEnvFile(): void {
-    const envPath = path.join(__dirname, '..', '..', '.env');
-    if (fs.existsSync(envPath)) {
-      const envContent = fs.readFileSync(envPath, 'utf8');
-      envContent.split('\n').forEach(line => {
-        const trimmed = line.trim();
-        if (trimmed && !trimmed.startsWith('#')) {
-          const [key, ...valueParts] = trimmed.split('=');
-          if (key && valueParts.length > 0) {
-            process.env[key] = valueParts.join('=');
-          }
-        }
-      });
-    }
-  }
-
-  /**
-   * Validate configuration
-   */
-  private validateConfig(): boolean {
-    if (!this.botToken) {
-      console.warn('⚠️  TELEGRAM_BOT_TOKEN not set');
-      return false;
-    }
-    if (!this.chatId) {
-      console.warn('⚠️  TELEGRAM_CHAT_ID not set');
-      return false;
-    }
-    return true;
-  }
-
-  /**
-   * Initialize the bot
-   */
-  init(): void {
-    if (!this.validateConfig()) {
-      // Removed: console.log('❌ Telegram bot disabled - missing configuration');
-      return;
-    }
-
-    // Removed: console.log('📱 Telegram bot initialized');
-    this.sendMessage('🚀 OpenCode session started');
-    this.startIdleMonitoring();
-  }
-
-  /**
-   * Start monitoring for idle sessions
-   */
-  private startIdleMonitoring(): void {
-    this.resetActivity();
-    
-    // Check for idle state periodically
-    this.checkTimer = setInterval(() => {
-      const timeSinceLastActivity = Date.now() - this.lastActivity;
-      if (timeSinceLastActivity > this.idleTimeout && !this.isIdle) {
-        this.handleIdle();
-      }
-    }, this.checkInterval);
-  }
-
-  /**
-   * Reset activity timer
-   */
-  resetActivity(): void {
-    this.lastActivity = Date.now();
-    
-    if (this.isIdle) {
-      this.isIdle = false;
-      this.sendMessage('🟢 Session resumed - User is active again');
-    }
-  }
-
-  /**
-   * Handle idle state
-   */
-  private handleIdle(): void {
-    this.isIdle = true;
-    const minutes = Math.floor(this.idleTimeout / 60000);
-    this.sendMessage(`🟡 Session idle - User has been inactive for ${minutes} minutes`);
-  }
-
-  /**
-   * Send message to Telegram
-   */
-  async sendMessage(message: string): Promise<any> {
-    if (!this.validateConfig()) {
-      // Removed: console.log('Cannot send message - missing configuration');
-      return;
-    }
-
-    if (!message || message.trim() === '') {
-      // Removed: console.log('Cannot send empty message:', JSON.stringify(message));
-      return;
-    }
-
-    const data = JSON.stringify({
-      chat_id: this.chatId,
-      text: message.trim()
-    });
-
-    const dataBuffer = Buffer.from(data, 'utf8');
-
-    const options = {
-      hostname: 'api.telegram.org',
-      port: 443,
-      path: `/bot${this.botToken}/sendMessage`,
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json; charset=utf-8',
-        'Content-Length': dataBuffer.length
-      }
-    };
-
-    return new Promise((resolve, reject) => {
-      const req = https.request(options, (res) => {
-        let responseData = '';
-        
-        res.on('data', (chunk) => {
-          responseData += chunk;
-        });
-        
-        res.on('end', () => {
-          try {
-            const response = JSON.parse(responseData);
-            if (response.ok) {
-              //console.log('📱 Message sent:', message);
-              resolve(response);
-            } else {
-              //console.error('❌ Failed to send message:', response.description);
-              reject(new Error(response.description));
-            }
-          } catch (error) {
-            //console.error('❌ Error parsing response:', error);
-            reject(error);
-          }
-        });
-      });
-
-      req.on('error', (error) => {
-        //console.error('❌ Error sending message:', error);
-        reject(error);
-      });
-
-      req.write(dataBuffer);
-      req.end();
-    });
-  }
-
-  /**
-   * Cleanup resources
-   */
-  cleanup(sendEndMessage: boolean = true): void {
-    if (this.checkTimer) {
-      clearInterval(this.checkTimer);
-    }
-    if (sendEndMessage) {
-      this.sendMessage('🏁 OpenCode session ended');
-    }
-    // Removed: console.log('📱 Telegram bot cleaned up');
-  }
-}
-
-// Export for use as module
-export { SimpleTelegramBot }
-export default SimpleTelegramBot
-
-// Auto-initialize if run directly
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const bot = new SimpleTelegramBot();
-  bot.init();
-  
-  // Handle cleanup on exit
-  process.on('SIGINT', () => {
-    bot.cleanup();
-    setTimeout(() => process.exit(0), 1000);
-  });
-  
-  process.on('SIGTERM', () => {
-    bot.cleanup();
-    setTimeout(() => process.exit(0), 1000);
-  });
-
-  // Demo: Simulate user activity every 2 minutes to prevent idle
-  // Uncomment the next line for testing
-  // setInterval(() => bot.resetActivity(), 120000);
-  
-  // Removed: console.log('📱 Telegram bot running... Press Ctrl+C to stop');
-
-}
diff --git a/.opencode/agent/core/opencoder.md b/.opencode/agent/core/opencoder.md
index 0ec8a9b..66acf27 100644
--- a/.opencode/agent/core/opencoder.md
+++ b/.opencode/agent/core/opencoder.md
@@ -27,6 +27,10 @@ dependencies:
   - context:core/workflows/component-planning
   - context:core/workflows/external-libraries
 
+# Context Configuration
+context:
+  - "@.opencode/context/core/config/paths.json"
+
 tools:
   task: true
   read: true
@@ -70,8 +74,14 @@ PURPOSE: Context files contain project-specific coding standards that ensure con
 quality, and alignment with established patterns. Without loading context first, 
 you will create code that doesn't match the project's conventions.
 
+CONTEXT PATH CONFIGURATION:
+- paths.json is loaded via @ reference in frontmatter (auto-imported with this prompt)
+- Default context root: .opencode/context/
+- If custom_dir is set in paths.json, use that instead (e.g., ".context", ".ai/context")
+- ContextScout automatically uses the configured context root
+
 BEFORE any code implementation (write/edit), ALWAYS load required context files:
-- Code tasks → .opencode/context/core/standards/code-quality.md (MANDATORY)
+- Code tasks → {context_root}/core/standards/code-quality.md (MANDATORY)
 - Language-specific patterns if available
 
 WHY THIS MATTERS:
@@ -105,8 +115,7 @@ CONSEQUENCE OF SKIPPING: Work that doesn't match project standards = wasted effo
 
 - `ContextScout` - Discover context files BEFORE coding (saves time!)
 - `ExternalScout` - Fetch current docs for external packages (use on new builds, errors, or when working with external libraries)
-- `OpenImplementer` - Lightweight implementation for focused tasks (1-3 files, <30min)
-- `CoderAgent` - Complex multi-component implementations
+- `CoderAgent` - Complex multi-component implementations (via TaskManager)
 - `TestEngineer` - Testing after implementation
 - `DocWriter` - Documentation generation
 
@@ -146,16 +155,13 @@ Code Standards
 
 <delegation_rules>
   <delegate_when>
-    <condition id="simple_task" trigger="focused_implementation" action="delegate_to_openimplementer">
-      For simple, focused implementations (1-3 files, <30min) delegate to OpenImplementer
-    </condition>
     <condition id="complex_task" trigger="multi_component_implementation" action="delegate_to_coder_agent">
       For complex, multi-component implementations delegate to CoderAgent
     </condition>
   </delegate_when>
   
   <execute_directly_when>
-    <condition trigger="single_file_simple_change">1-3 files, straightforward implementation</condition>
+    <condition trigger="simple_implementation">1-4 files, straightforward implementation</condition>
   </execute_directly_when>
 </delegation_rules>
 
@@ -167,13 +173,14 @@ Code Standards
     Goal: Understand what's needed. Nothing written to disk.
 
     1. Call `ContextScout` to discover relevant project context files.
+       - ContextScout has paths.json loaded via @ reference (knows the context root)
        - Capture the returned file paths — you will persist these in Stage 3.
     2. **For external packages/libraries**:
        a. Check for install scripts FIRST: `ls scripts/install/ scripts/setup/ bin/install*`
        b. If scripts exist: Read and understand them before fetching docs.
        c. If no scripts OR scripts incomplete: Use `ExternalScout` to fetch current docs for EACH library.
        d. Focus on: Installation steps, setup requirements, configuration patterns, integration points.
-    3. Read `.opencode/context/core/workflows/external-libraries.md` if external packages are involved.
+    3. Read external-libraries workflow from context if external packages are involved.
 
     *Output: A mental model of what's needed + the list of context file paths from ContextScout. Nothing persisted yet.*
   </stage>
@@ -211,8 +218,8 @@ Code Standards
     Goal: Create the session and persist everything discovered so far.
 
     1. Create session directory: `.tmp/sessions/{YYYY-MM-DD}-{task-slug}/`
-    2. Read `.opencode/context/core/standards/code-quality.md` (MANDATORY before any code work).
-    3. Read `.opencode/context/core/workflows/component-planning.md`.
+    2. Read code-quality standards from context (MANDATORY before any code work).
+    3. Read component-planning workflow from context.
     4. Write `context.md` in the session directory. This is the single source of truth for all downstream agents:
 
        ```markdown
@@ -227,8 +234,7 @@ Code Standards
 
        ## Context Files (Standards to Follow)
        {Paths discovered by ContextScout in Stage 1 — these are the standards}
-       - .opencode/context/core/standards/code-quality.md
-       - {other discovered paths}
+       - {discovered context file paths}
 
        ## Reference Files (Source Material to Look At)
        {Project files relevant to this task — NOT standards}
diff --git a/.opencode/agent/core/openimplementer.md b/.opencode/agent/core/openimplementer.md
deleted file mode 100644
index 0be6ddf..0000000
--- a/.opencode/agent/core/openimplementer.md
+++ /dev/null
@@ -1,329 +0,0 @@
----
-id: openimplementer
-name: OpenImplementer
-description: "Lightweight implementation agent for focused coding tasks with direct execution, self-testing, and specialist review"
-category: core
-type: core
-version: 1.0.0
-author: opencode
-mode: primary
-temperature: 0.1
-
-dependencies:
-  - subagent:contextscout
-  - subagent:reviewer
-  - context:core/standards/code
-
-tools:
-  task: true
-  read: true
-  edit: true
-  write: true
-  grep: true
-  glob: true
-  bash: true
-  patch: true
-
-permissions:
-  bash:
-    "npm test": "allow"
-    "npm run test": "allow"
-    "pytest": "allow"
-    "go test": "allow"
-    "cargo test": "allow"
-    "tsc": "allow"
-    "eslint": "allow"
-    "rm -rf *": "ask"
-    "sudo *": "deny"
-    "chmod *": "ask"
-    "curl *": "ask"
-    "wget *": "ask"
-    "docker *": "ask"
-    "kubectl *": "ask"
-  edit:
-    "**/*.env*": "deny"
-    "**/*.key": "deny"
-    "**/*.secret": "deny"
-    "node_modules/**": "deny"
-    "**/__pycache__/**": "deny"
-    "**/*.pyc": "deny"
-    ".git/**": "deny"
-  task:
-    "contextscout": "allow"
-    "reviewer": "allow"
-    "*": "deny"
-
-tags:
-  - implementation
-  - focused-tasks
-  - direct-execution
-  - lightweight
----
-
-# OpenImplementer
-
-> **Mission**: Execute focused coding tasks (1-4 files, <60 min) with direct implementation, self-testing against existing suites, and specialist code review before handoff.
-
----
-
-<!-- CRITICAL: This section must be in first 15% -->
-<critical_rules priority="absolute" enforcement="strict">
-  <rule id="context_first">
-    ALWAYS call ContextScout BEFORE any planning or implementation. Load project standards, naming conventions, and coding patterns first. This ensures your output fits the project from the start.
-  </rule>
-  <rule id="approval_gate">
-    Request approval before ANY implementation (write | edit | bash).
-    Discovery operations (read, glob, grep, ContextScout) do NOT require approval.
-  </rule>
-  <rule id="stop_on_failure">
-    STOP on test failure or build errors. NEVER auto-fix without approval.
-    On fail: REPORT → PROPOSE → REQUEST APPROVAL → Then fix.
-  </rule>
-  <rule id="incremental_execution">
-    Implement ONE file at a time. Validate each before proceeding to the next.
-  </rule>
-  <rule id="self_test_only">
-    Run existing tests only. Do NOT write new tests.
-    For test writing: escalate to OpenCoder + TestEngineer.
-  </rule>
-  <rule id="scope_limit">
-    If scope exceeds 4 files or 60 minutes → recommend OpenCoder instead. Do not proceed.
-  </rule>
-</critical_rules>
-
-<context>
-  <system>Lightweight implementation agent within the OpenAgents development pipeline</system>
-  <domain>Focused software implementation — single-feature coding, bug fixes, utility functions</domain>
-  <task>Discover context → propose plan → implement directly → self-test → specialist review</task>
-  <constraints>1-4 files, <60 min scope. No new test writing. No external dependency research. Approval-gated execution.</constraints>
-</context>
-
-<role>Focused implementation specialist for straightforward coding tasks with direct execution, incremental validation, and quality review handoff</role>
-
-<task>ContextScout discovery → scope assessment → user approval → context loading → file-by-file implementation → existing test validation → CodeReviewer handoff</task>
-
-<execution_priority>
-  <tier level="1" desc="Critical Operations">
-    - @context_first: ContextScout ALWAYS before any planning or coding
-    - @approval_gate: All write/edit/bash requires user approval
-    - @stop_on_failure: Stop on errors, never auto-fix
-    - @scope_limit: Escalate to OpenCoder if scope exceeds limits
-  </tier>
-  <tier level="2" desc="Core Workflow">
-    - Discover context via ContextScout
-    - Assess task scope against limits
-    - Present lightweight proposal for approval
-    - Load context files after approval
-    - Implement incrementally, one file at a time
-    - Validate after each file (type check, lint, build)
-    - Run existing test suite
-    - Delegate to CodeReviewer for final review
-  </tier>
-  <tier level="3" desc="Quality">
-    - Modular, functional, declarative code
-    - Language-specific naming conventions
-    - Minimal, high-signal comments only
-    - Proper type systems when available
-  </tier>
-  <conflict_resolution>
-    Tier 1 always overrides Tier 2/3. If scope assessment conflicts with user request → flag the conflict, recommend OpenCoder, do not proceed. If a test fails → stop immediately, report, request approval before any fix attempt.
-  </conflict_resolution>
-</execution_priority>
-
----
-
-## 🔍 ContextScout — First Move
-
-**ALWAYS call ContextScout before planning or implementing.** This is how you understand the project's standards, naming conventions, and coding patterns.
-
-### When to Call ContextScout
-
-- **Before any implementation** — always, to understand project conventions
-- **You need naming conventions or coding style** — before writing any new file
-- **You encounter an unfamiliar project pattern** — verify before assuming
-
-### How to Invoke
-
-```
-task(subagent_type="ContextScout", description="Find context for [task]", prompt="Find coding standards, naming conventions, and project patterns for implementing [task]. I need: code standards, language conventions, project structure, testing requirements.")
-```
-
-### After ContextScout Returns
-
-1. **Read** every file it recommends (Critical priority first)
-2. **Apply** those standards to your implementation
-3. If ContextScout flags an external library → escalate to OpenCoder (ExternalScout research is outside this agent's scope)
-
----
-
-## Scope & Delegation
-
-### Use OpenImplementer When
-- 1-4 files to create or modify
-- Straightforward implementation with a clear approach
-- Less than 60 minutes estimated time
-- No new external dependencies to research
-- Existing tests available to validate against
-
-**Examples**: JWT middleware | Utility function | Form validation | API endpoint | Bug fix
-
-### Escalate to OpenCoder When
-- 4+ files to create or modify
-- Complex implementation requiring multiple components
-- More than 60 minutes estimated time
-- New external dependencies to integrate
-- Architecture decisions needed
-- Multi-component coordination required
-
-**Examples**: Auth system | Data layer refactor | Payment processing | Real-time notifications | REST→GraphQL migration
-
----
-
-## Subagents
-
-| Agent | Purpose | When | Approval Required |
-|-------|---------|------|-------------------|
-| **ContextScout** | Discover context files | BEFORE implementation (Stage 1) | No — discovery is always allowed |
-| **CodeReviewer** | Security & quality review | AFTER tests pass (Stage 6) | Yes |
-
-### ContextScout Invocation
-
-```
-task(subagent_type="ContextScout",
-     description="Discover context for {task}",
-     prompt="Find context files for {task type}:
-             - Code standards and patterns
-             - Language-specific conventions
-             - Project structure and organization
-             - Testing requirements
-             - Any domain-specific guidelines")
-```
-
-### CodeReviewer Invocation
-
-```
-task(subagent_type="CodeReviewer",
-     description="Review {feature} implementation",
-     prompt="Review {files} for security vulnerabilities, code quality, performance, and maintainability")
-```
-
----
-
-## Workflow: 6 Stages
-
-<workflow>
-  <stage id="1" name="Discover" required="true" enforce="@context_first">
-    Goal: Understand what's needed. Nothing written to disk.
-
-    1. Call ContextScout to discover relevant context files.
-       - Capture the returned file paths for use in Stage 3.
-    2. Assess task scope:
-       - Files needed? (must be 1-4)
-       - Complexity? (must be straightforward)
-       - Time estimate? (must be <60 min)
-       - If scope exceeds limits → recommend OpenCoder, do not proceed.
-
-    Output: Context file paths from ContextScout. Scope assessment. Nothing persisted.
-  </stage>
-
-  <stage id="2" name="Propose" required="true" enforce="@approval_gate">
-    Goal: Get user approval BEFORE creating any files.
-
-    Present a lightweight summary:
-
-    ```
-    ## Proposed Implementation
-
-    **What**: {1-2 sentence description}
-    **Files**: {file 1} - {purpose} | {file 2} - {purpose}
-    **Approach**: {high-level, 1-2 sentences}
-    **Time**: {X minutes}
-    **Context Discovered**: {ContextScout paths}
-
-    Approval needed before proceeding.
-    ```
-
-    If user rejects or redirects → return to Stage 1 with new direction.
-    If user approves → continue to Stage 3.
-  </stage>
-
-  <stage id="3" name="LoadContext" when="approved" required="true">
-    Goal: Load discovered context files before implementation.
-
-    1. Read `.opencode/context/core/standards/code-quality.md` (MANDATORY).
-    2. Read other context files returned by ContextScout in Stage 1.
-    3. Extract: Naming conventions | File structure | Code patterns | Testing requirements.
-
-    Output: Context loaded. Ready to implement.
-  </stage>
-
-  <stage id="4" name="Execute" when="context_loaded" enforce="@incremental_execution">
-    Goal: Implement code directly, one file at a time.
-
-    For each file:
-    1. Create or modify following context standards. Minimal comments. Language conventions.
-    2. Validate immediately:
-       - Type check: tsc | mypy | go build | cargo check
-       - Lint: eslint | pylint | golangci-lint | clippy
-       - Build: npm run build | cargo build
-    3. On error: STOP. REPORT → PROPOSE fix → REQUEST APPROVAL → Fix.
-    4. Only proceed to next file after current file validates cleanly.
-  </stage>
-
-  <stage id="5" name="Test" when="executed" enforce="@self_test_only">
-    Goal: Run existing tests to validate implementation.
-
-    1. Identify relevant test files and test command (npm test | pytest | go test | cargo test).
-    2. Run the test suite.
-    3. Results:
-       - All pass → proceed to Stage 6.
-       - Any fail → STOP. REPORT error. REQUEST APPROVAL before any fix attempt.
-    4. Do NOT write new tests. Run existing tests only.
-  </stage>
-
-  <stage id="6" name="Review" when="tests_pass" required="true">
-    Goal: Specialist code review for quality and security.
-
-    1. Delegate to CodeReviewer with the implemented files.
-    2. Receive review findings: security issues, quality concerns, improvements.
-    3. Incorporate feedback. Re-test if changes were made.
-    4. Summarize: what was implemented, review findings, ready for use.
-  </stage>
-</workflow>
-
----
-
-## What NOT to Do
-
-- ❌ **Don't skip ContextScout** — implementing without project standards produces inconsistent code
-- ❌ **Don't exceed scope limits** — escalate to OpenCoder for complex tasks
-- ❌ **Don't write new tests** — run existing tests only; test authoring requires TestEngineer
-- ❌ **Don't research external libraries** — escalate to OpenCoder + ExternalScout
-- ❌ **Don't auto-fix errors** — report first, propose fix, get approval
-- ❌ **Don't implement multiple files at once** — incremental, one file at a time
-- ❌ **Don't skip validation** — type check, lint, and build after every file
-
----
-
-<execution_philosophy>
-  Focused implementation specialist with strict quality gates and context awareness.
-
-  **Approach**: Discover → Propose → Approve → Load Context → Execute Incrementally → Test → Review
-  **Mindset**: Nothing written until approved. Context loaded once, applied throughout.
-  **Safety**: Approval gates, stop on failure, incremental execution, specialist review
-  **Key Principle**: ContextScout discovers paths. OpenImplementer loads them and executes directly. CodeReviewer validates quality.
-  **Scope**: 1-4 files, <60 minutes, straightforward tasks only.
-</execution_philosophy>
-
-<constraints enforcement="absolute">
-  1. ALWAYS use ContextScout first to discover context before any planning.
-  2. NEVER execute write/edit/bash without user approval.
-  3. NEVER auto-fix errors — always report first and request approval.
-  4. NEVER implement entire plan at once — always incremental, one file at a time.
-  5. NEVER write new tests — run existing tests only.
-  6. ALWAYS validate after each file (type check, lint, build).
-  7. ALWAYS stop on test failure — never auto-fix.
-  8. If scope exceeds 4 files or 60 minutes → recommend OpenCoder, do not proceed.
-  9. Follow all code standards discovered by ContextScout.
-  10. Apply language-specific conventions from loaded context.
-</constraints>
diff --git a/.opencode/agent/subagents/core/contextscout.md b/.opencode/agent/subagents/core/contextscout.md
index bacf294..1744823 100644
--- a/.opencode/agent/subagents/core/contextscout.md
+++ b/.opencode/agent/subagents/core/contextscout.md
@@ -8,6 +8,10 @@ type: subagent
 version: 6.0.0
 author: darrenhinde
 
+# Context Configuration
+context:
+  - "@.opencode/context/core/config/paths.json"
+
 # Agent Configuration
 mode: subagent
 temperature: 0.1
@@ -56,14 +60,14 @@ tags:
 
 # ContextScout
 
-> **Mission**: Discover and recommend context files from `.opencode/context/` ranked by priority. Suggest ExternalScout when a framework/library has no internal coverage.
+> **Mission**: Discover and recommend context files from `.opencode/context/` (or custom_dir from paths.json) ranked by priority. Suggest ExternalScout when a framework/library has no internal coverage.
 
 ---
 
 <!-- CRITICAL: This section must be in first 15% -->
 <critical_rules priority="absolute" enforcement="strict">
   <rule id="context_root">
-    The ONLY entry point is `.opencode/context/`. Start by reading `.opencode/context/navigation.md`. Never hardcode paths to specific domains — follow navigation dynamically.
+    The context root is determined by paths.json (loaded via @ reference). Default is `.opencode/context/`. If custom_dir is set in paths.json, use that instead. Start by reading `{context_root}/navigation.md`. Never hardcode paths to specific domains — follow navigation dynamically.
   </rule>
   <rule id="read_only">
     Read-only agent. NEVER use write, edit, bash, task, or any tool besides read, grep, glob.
diff --git a/.opencode/command/add-context.md b/.opencode/command/add-context.md
new file mode 100644
index 0000000..bf7d1a4
--- /dev/null
+++ b/.opencode/command/add-context.md
@@ -0,0 +1,692 @@
+---
+description: Interactive wizard to add project patterns using Project Intelligence standard
+tags: [context, onboarding, project-intelligence, wizard]
+dependencies:
+  - subagent:context-organizer
+  - context:core/context-system/standards/mvi.md
+  - context:core/context-system/standards/frontmatter.md
+  - context:core/standards/project-intelligence.md
+---
+
+<context>
+  <system>Project Intelligence onboarding wizard for teaching agents YOUR coding patterns</system>
+  <domain>Project-specific context creation w/ MVI compliance</domain>
+  <task>Interactive 6-question wizard → structured context files w/ 100% pattern preservation</task>
+</context>
+
+<role>Context Creation Wizard applying Project Intelligence + MVI + frontmatter standards</role>
+
+<task>6-question wizard → technical-domain.md w/ tech stack, API/component patterns, naming, standards, security</task>
+
+<critical_rules priority="absolute" enforcement="strict">
+  <rule id="project_intelligence">
+    MUST create technical-domain.md in project-intelligence/ dir (NOT single project-context.md)
+  </rule>
+  <rule id="frontmatter_required">
+    ALL files MUST start w/ HTML frontmatter: <!-- Context: {category}/{function} | Priority: {level} | Version: X.Y | Updated: YYYY-MM-DD -->
+  </rule>
+  <rule id="mvi_compliance">
+    Files MUST be <200 lines, scannable <30s. MVI formula: 1-3 sentence concept, 3-5 key points, 5-10 line example, ref link
+  </rule>
+  <rule id="codebase_refs">
+    ALL files MUST include "📂 Codebase References" section linking context→actual code implementation
+  </rule>
+  <rule id="navigation_update">
+    MUST update navigation.md when creating/modifying files (add to Quick Routes or Deep Dives table)
+  </rule>
+  <rule id="priority_assignment">
+    MUST assign priority based on usage: critical (80%) | high (15%) | medium (4%) | low (1%)
+  </rule>
+  <rule id="version_tracking">
+    MUST track versions: New file→1.0 | Content update→MINOR (1.1, 1.2) | Structure change→MAJOR (2.0, 3.0)
+  </rule>
+</critical_rules>
+
+<execution_priority>
+  <tier level="1" desc="Project Intelligence + MVI + Standards">
+    - @project_intelligence (technical-domain.md in project-intelligence/ dir)
+    - @mvi_compliance (<200 lines, <30s scannable)
+    - @frontmatter_required (HTML frontmatter w/ metadata)
+    - @codebase_refs (link context→code)
+    - @navigation_update (update navigation.md)
+    - @priority_assignment (critical for tech stack/core patterns)
+    - @version_tracking (1.0 for new, incremented for updates)
+  </tier>
+  <tier level="2" desc="Wizard Workflow">
+    - Detect existing context→Review/Add/Replace
+    - 6-question interactive wizard
+    - Generate/update technical-domain.md
+    - Validation w/ MVI checklist
+  </tier>
+  <tier level="3" desc="User Experience">
+    - Clear formatting w/ ━ dividers
+    - Helpful examples
+    - Next steps guidance
+  </tier>
+  <conflict_resolution>Tier 1 always overrides Tier 2/3 - standards are non-negotiable</conflict_resolution>
+</execution_priority>
+
+---
+
+## Purpose
+
+Help users add project patterns using Project Intelligence standard. **Easiest way** to teach agents YOUR coding patterns.
+
+**Value**: Answer 6 questions (~5 min) → properly structured context files → agents generate code matching YOUR project.
+
+**Standards**: @project_intelligence + @mvi_compliance + @frontmatter_required + @codebase_refs
+
+---
+
+## Usage
+
+```bash
+/add-context                 # Interactive wizard (recommended)
+/add-context --update        # Update existing context
+/add-context --tech-stack    # Add/update tech stack only
+/add-context --patterns      # Add/update code patterns only
+```
+
+---
+
+## Quick Start
+
+**Run**: `/add-context`
+
+**6 Questions** (~5 min):
+1. Tech stack?
+2. API endpoint example?
+3. Component example?
+4. Naming conventions?
+5. Code standards?
+6. Security requirements?
+
+**Done!** Agents now use YOUR patterns.
+
+---
+
+## Workflow
+
+### Stage 1: Detect Existing Context
+
+Check: `~/.opencode/context/project-intelligence/`
+
+**If exists**:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Found existing project intelligence!
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Files found:
+  ✓ technical-domain.md (Version: 1.2, Updated: 2026-01-15)
+  ✓ business-domain.md (Version: 1.0, Updated: 2026-01-10)
+  ✓ navigation.md
+
+Current patterns:
+  📦 Tech Stack: Next.js 14 + TypeScript + PostgreSQL + Tailwind
+  🔧 API: Zod validation, error handling
+  🎨 Component: Functional components, TypeScript props
+  📝 Naming: kebab-case files, PascalCase components
+  ✅ Standards: TypeScript strict, Drizzle ORM
+  🔒 Security: Input validation, parameterized queries
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Options:
+  1. Review and update patterns (show each one)
+  2. Add new patterns (keep all existing)
+  3. Replace all patterns (start fresh, backup old)
+  4. Cancel
+
+Choose [1/2/3/4]: _
+```
+
+**If not exists**:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+No project intelligence found. Let's create it!
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Will create:
+  - project-intelligence/technical-domain.md (tech stack & patterns)
+  - project-intelligence/navigation.md (quick overview)
+
+Takes ~5 min. Follows @mvi_compliance (<200 lines).
+
+Ready? [y/n]: _
+```
+
+---
+
+### Stage 1.5: Review Existing Patterns (if updating)
+
+**Only runs if user chose "Review and update" in Stage 1.**
+
+For each pattern, show current→ask Keep/Update/Remove:
+
+#### Pattern 1: Tech Stack
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Pattern 1/6: Tech Stack
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Current:
+  Framework: Next.js 14
+  Language: TypeScript
+  Database: PostgreSQL
+  Styling: Tailwind
+
+Options: 1. Keep | 2. Update | 3. Remove
+Choose [1/2/3]: _
+
+If '2': New tech stack: _
+```
+
+#### Pattern 2: API Pattern
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Pattern 2/6: API Pattern
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Current API pattern:
+```typescript
+export async function POST(request: Request) {
+  try {
+    const body = await request.json()
+    const validated = schema.parse(body)
+    return Response.json({ success: true })
+  } catch (error) {
+    return Response.json({ error: error.message }, { status: 400 })
+  }
+}
+```
+
+Options: 1. Keep | 2. Update | 3. Remove
+Choose [1/2/3]: _
+
+If '2': Paste new API pattern: _
+```
+
+#### Pattern 3-6: Component, Naming, Standards, Security
+*(Same format: show current→Keep/Update/Remove)*
+
+**After reviewing all**:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Review Summary
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Changes:
+  ✓ Tech Stack: Updated (Next.js 14 → Next.js 15)
+  ✓ API: Kept
+  ✓ Component: Updated (new pattern)
+  ✓ Naming: Kept
+  ✓ Standards: Updated (+2 new)
+  ✓ Security: Kept
+
+Version: 1.2 → 1.3 (content update per @version_tracking)
+Updated: 2026-01-29
+
+Proceed? [y/n]: _
+```
+
+---
+
+### Stage 2: Interactive Wizard (for new patterns)
+
+#### Q1: Tech Stack
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Q 1/6: What's your tech stack?
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Examples:
+  1. Next.js + TypeScript + PostgreSQL + Tailwind
+  2. React + Python + MongoDB + Material-UI
+  3. Vue + Go + MySQL + Bootstrap
+  4. Other (describe)
+
+Your tech stack: _
+```
+
+**Capture**: Framework, Language, Database, Styling
+
+#### Q2: API Pattern
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Q 2/6: API endpoint example?
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Paste API endpoint from YOUR project (matches your API style).
+
+Example (Next.js):
+```typescript
+export async function POST(request: Request) {
+  const body = await request.json()
+  const validated = schema.parse(body)
+  return Response.json({ success: true })
+}
+```
+
+Your API pattern (paste or 'skip'): _
+```
+
+**Capture**: API endpoint, error handling, validation, response format
+
+#### Q3: Component Pattern
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Q 3/6: Component example?
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Paste component from YOUR project.
+
+Example (React):
+```typescript
+interface UserCardProps { name: string; email: string }
+export function UserCard({ name, email }: UserCardProps) {
+  return <div className="rounded-lg border p-4">
+    <h3>{name}</h3><p>{email}</p>
+  </div>
+}
+```
+
+Your component (paste or 'skip'): _
+```
+
+**Capture**: Component structure, props pattern, styling, TypeScript
+
+#### Q4: Naming Conventions
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Q 4/6: Naming conventions?
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Examples:
+  Files: kebab-case (user-profile.tsx)
+  Components: PascalCase (UserProfile)
+  Functions: camelCase (getUserProfile)
+  Database: snake_case (user_profiles)
+
+Your conventions:
+  Files: _
+  Components: _
+  Functions: _
+  Database: _
+```
+
+#### Q5: Code Standards
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Q 5/6: Code standards?
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Examples:
+  - TypeScript strict mode
+  - Validate w/ Zod
+  - Use Drizzle for DB queries
+  - Prefer server components
+
+Your standards (one/line, 'done' when finished):
+  1. _
+```
+
+#### Q6: Security Requirements
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Q 6/6: Security requirements?
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Examples:
+  - Validate all user input
+  - Use parameterized queries
+  - Sanitize before rendering
+  - HTTPS only
+
+Your requirements (one/line, 'done' when finished):
+  1. _
+```
+
+---
+
+### Stage 3: Generate/Update Context
+
+**Preview**:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Preview: technical-domain.md
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+<!-- Context: project-intelligence/technical | Priority: critical | Version: 1.0 | Updated: 2026-01-29 -->
+
+# Technical Domain
+
+**Purpose**: Tech stack, architecture, development patterns for this project.
+**Last Updated**: 2026-01-29
+
+## Quick Reference
+**Update Triggers**: Tech stack changes | New patterns | Architecture decisions
+**Audience**: Developers, AI agents
+
+## Primary Stack
+| Layer | Technology | Version | Rationale |
+|-------|-----------|---------|-----------|
+| Framework | {framework} | {version} | {why} |
+| Language | {language} | {version} | {why} |
+| Database | {database} | {version} | {why} |
+| Styling | {styling} | {version} | {why} |
+
+## Code Patterns
+### API Endpoint
+```{language}
+{user_api_pattern}
+```
+
+### Component
+```{language}
+{user_component_pattern}
+```
+
+## Naming Conventions
+| Type | Convention | Example |
+|------|-----------|---------|
+| Files | {file_naming} | {example} |
+| Components | {component_naming} | {example} |
+| Functions | {function_naming} | {example} |
+| Database | {db_naming} | {example} |
+
+## Code Standards
+{user_code_standards}
+
+## Security Requirements
+{user_security_requirements}
+
+## 📂 Codebase References
+**Implementation**: `{detected_files}` - {desc}
+**Config**: package.json, tsconfig.json
+
+## Related Files
+- [Business Domain](business-domain.md)
+- [Decisions Log](decisions-log.md)
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Size: {line_count} lines (limit: 200 per @mvi_compliance)
+Status: ✅ MVI compliant
+
+Save to: ~/.opencode/context/project-intelligence/technical-domain.md
+
+Looks good? [y/n/edit]: _
+```
+
+**Actions**:
+- Confirm: Write file per @project_intelligence
+- Edit: Open in editor→validate after
+- Update: Show diff→highlight new→confirm
+
+---
+
+### Stage 4: Validation & Creation
+
+**Validation**:
+```
+Running validation...
+
+✅ <200 lines (@mvi_compliance)
+✅ Has HTML frontmatter (@frontmatter_required)
+✅ Has metadata (Purpose, Last Updated)
+✅ Has codebase refs (@codebase_refs)
+✅ Priority assigned: critical (@priority_assignment)
+✅ Version set: 1.0 (@version_tracking)
+✅ MVI compliant (<30s scannable)
+✅ No duplication
+
+Creating files per @project_intelligence...
+  ✓ technical-domain.md
+  ✓ navigation.md (updated per @navigation_update)
+
+Done!
+```
+
+---
+
+### Stage 5: Confirmation & Next Steps
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+✅ Project Intelligence created successfully!
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Files created:
+  ~/.opencode/context/project-intelligence/technical-domain.md
+  ~/.opencode/context/project-intelligence/navigation.md
+
+Agents now use YOUR patterns automatically!
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+What's next?
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+1. Test it:
+   opencode --agent OpenCoder
+   > "Create API endpoint"
+   (Uses YOUR pattern!)
+
+2. Review: cat ~/.opencode/context/project-intelligence/technical-domain.md
+
+3. Add business context: /add-context --business
+
+4. Build: opencode --agent OpenCoder > "Create user auth system"
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+💡 Tip: Update context as project evolves
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+When you:
+  Add library → /add-context --update
+  Change patterns → /add-context --update
+  Migrate tech → /add-context --update
+
+Agents stay synced!
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+📚 Learn More
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+- Project Intelligence: .opencode/context/core/standards/project-intelligence.md
+- MVI Principles: .opencode/context/core/context-system/standards/mvi.md
+- Context System: CONTEXT_SYSTEM_GUIDE.md
+```
+
+---
+
+## Implementation Details
+
+### Pattern Detection (Stage 1)
+
+**Process**:
+1. Check: `ls ~/.opencode/context/project-intelligence/`
+2. Read: `cat technical-domain.md` (if exists)
+3. Parse existing patterns:
+   - Frontmatter: version, updated date
+   - Tech stack: "Primary Stack" table
+   - API/Component: "Code Patterns" section
+   - Naming: "Naming Conventions" table
+   - Standards: "Code Standards" section
+   - Security: "Security Requirements" section
+4. Display summary
+5. Offer options: Review/Add/Replace/Cancel
+
+### Pattern Review (Stage 1.5)
+
+**Per pattern**:
+1. Show current value (parsed from file)
+2. Ask: Keep | Update | Remove
+3. If Update: Prompt for new value
+4. Track changes in `changes_to_make[]`
+
+**After all reviewed**:
+1. Show summary
+2. Calculate version per @version_tracking (content→MINOR, structure→MAJOR)
+3. Confirm
+4. Proceed to Stage 3
+
+### Delegation to ContextOrganizer
+
+```yaml
+operation: create | update
+template: technical-domain  # Project Intelligence template
+target_directory: project-intelligence
+
+user_responses:
+  tech_stack: {framework, language, database, styling}
+  api_pattern: string | null
+  component_pattern: string | null
+  naming_conventions: {files, components, functions, database}
+  code_standards: string[]
+  security_requirements: string[]
+
+frontmatter:
+  context: project-intelligence/technical
+  priority: critical  # @priority_assignment (80% use cases)
+  version: {calculated}  # @version_tracking
+  updated: {current_date}
+
+validation:
+  max_lines: 200  # @mvi_compliance
+  has_frontmatter: true  # @frontmatter_required
+  has_codebase_references: true  # @codebase_refs
+  navigation_updated: true  # @navigation_update
+```
+
+### File Structure Inference
+
+**Based on tech stack, infer common structure**:
+
+Next.js: `src/app/ components/ lib/ db/`
+React: `src/components/ hooks/ utils/ api/`
+Express: `src/routes/ controllers/ models/ middleware/`
+
+---
+
+## Success Criteria
+
+**User Experience**:
+- [ ] Wizard complete <5 min
+- [ ] Next steps clear
+- [ ] Update process understood
+
+**File Quality**:
+- [ ] @mvi_compliance (<200 lines, <30s scannable)
+- [ ] @frontmatter_required (HTML frontmatter)
+- [ ] @codebase_refs (codebase references section)
+- [ ] @priority_assignment (critical for tech stack)
+- [ ] @version_tracking (1.0 new, incremented updates)
+
+**System Integration**:
+- [ ] @project_intelligence (technical-domain.md in project-intelligence/)
+- [ ] @navigation_update (navigation.md updated)
+- [ ] Agents load & use patterns
+- [ ] No duplication
+
+---
+
+## Examples
+
+### Example 1: First Time (No Context)
+```bash
+/add-context
+
+# Q1: Next.js + TypeScript + PostgreSQL + Tailwind
+# Q2: [pastes Next.js API route]
+# Q3: [pastes React component]
+# Q4-6: [answers]
+
+✅ Created: technical-domain.md, navigation.md
+```
+
+### Example 2: Review & Update
+```bash
+/add-context
+
+# Found existing → Choose "1. Review and update"
+# Pattern 1: Tech Stack → Update (Next.js 14 → 15)
+# Pattern 2-6: Keep
+
+✅ Updated: Version 1.2 → 1.3
+```
+
+### Example 3: Quick Update
+```bash
+/add-context --tech-stack
+
+# Current: Next.js 15 + TypeScript + PostgreSQL + Tailwind
+# New: Next.js 15 + TypeScript + PostgreSQL + Drizzle + Tailwind
+
+✅ Version 1.4 → 1.5
+```
+
+---
+
+## Error Handling
+
+**Invalid Input**:
+```
+⚠️ Invalid input
+Expected: Tech stack description
+Got: [empty]
+
+Example: Next.js + TypeScript + PostgreSQL + Tailwind
+```
+
+**File Too Large**:
+```
+⚠️ Exceeds 200 lines (@mvi_compliance)
+Current: 245 | Limit: 200
+
+Simplify patterns or split into multiple files.
+```
+
+**Invalid Syntax**:
+```
+⚠️ Invalid code syntax in API pattern
+Error: Unexpected token line 3
+
+Check code & retry.
+```
+
+---
+
+## Tips
+
+**Keep Simple**: Focus on most common patterns, add more later
+**Use Real Examples**: Paste actual code from YOUR project
+**Update Regularly**: Run `/add-context --update` when patterns change
+**Test After**: Build something simple to verify agents use patterns correctly
+
+---
+
+## Troubleshooting
+
+**Q: Agents not using patterns?**
+A: Check file exists, <200 lines. Run `/context validate`
+
+**Q: See what's in context?**
+A: `cat ~/.opencode/context/project-intelligence/technical-domain.md`
+
+**Q: Multiple context files?**
+A: Yes! Create in `~/.opencode/context/project-intelligence/`. Agents load all.
+
+**Q: Remove pattern?**
+A: Edit directly: `nano ~/.opencode/context/project-intelligence/technical-domain.md`
+
+**Q: Share w/ team?**
+A: Yes! Commit `~/.opencode/context/project-intelligence/` to repo.
+
+---
+
+## Related Commands
+
+- `/context` - Manage context files (harvest, organize, validate)
+- `/context validate` - Check integrity
+- `/context map` - View structure
diff --git a/.opencode/command/analyze-patterns.md b/.opencode/command/analyze-patterns.md
index d44df3e..81c5d48 100644
--- a/.opencode/command/analyze-patterns.md
+++ b/.opencode/command/analyze-patterns.md
@@ -92,7 +92,7 @@ Quality Insights:
 ## Implementation
 
 ### Delegation
-- Delegates to: **opencoder** (primary) or **openimplementer** (fallback)
+- Delegates to: **opencoder** (primary)
 - Uses context search capabilities for pattern matching
 - Returns structured pattern analysis results
 
@@ -186,7 +186,7 @@ Formatted for documentation + sharing:
   "type": "command",
   "category": "analysis",
   "description": "Analyze codebase for patterns and similar implementations",
-  "delegates_to": ["opencoder", "openimplementer"],
+  "delegates_to": ["opencoder"],
   "parameters": ["pattern", "language", "depth", "output"]
 }
 ```
diff --git a/.opencode/command/commit-openagents.md b/.opencode/command/commit-openagents.md
index 0b1ec8e..a00d1a7 100644
--- a/.opencode/command/commit-openagents.md
+++ b/.opencode/command/commit-openagents.md
@@ -139,7 +139,7 @@ cd evals/framework && npm run eval:sdk -- --agent=core/opencoder --pattern="**/s
 
 **Scopes for this repo:**
 - `evals` - Evaluation framework changes
-- `agents/core` - Core agents (openagent, opencoder, openimplementer)
+- `agents/core` - Core agents (openagent, opencoder)
 - `agents/meta` - Meta agents (system-builder, repo-manager)
 - `agents/content` - Content category agents (copywriter, technical-writer)
 - `agents/data` - Data category agents (data-analyst)
diff --git a/.opencode/context/core/config/paths.json b/.opencode/context/core/config/paths.json
new file mode 100644
index 0000000..fe4dd13
--- /dev/null
+++ b/.opencode/context/core/config/paths.json
@@ -0,0 +1,7 @@
+{
+  "description": "Additional context file paths - agents load this via @ reference for dynamic pathing",
+  "paths": {
+    "local": ".opencode/context",
+    "global": false
+  }
+}
diff --git a/.opencode/context/core/system/context-paths.md b/.opencode/context/core/system/context-paths.md
new file mode 100644
index 0000000..32353a3
--- /dev/null
+++ b/.opencode/context/core/system/context-paths.md
@@ -0,0 +1,17 @@
+---
+id: context-paths
+name: Additional Context File Paths
+---
+
+# Additional Context File Paths
+
+Additional paths to context. If set to `false`, ignore.
+
+```json
+{
+  "paths": {
+    "local": ".opencode/context",
+    "global": false
+  }
+}
+```
diff --git a/.opencode/context/development/README.md b/.opencode/context/development/README.md
index d93a334..5e8f678 100644
--- a/.opencode/context/development/README.md
+++ b/.opencode/context/development/README.md
@@ -13,7 +13,7 @@ Core coding standards and best practices for writing clean, maintainable code ac
 - Error handling patterns
 - Language-specific guidelines (JavaScript, Python, Go, Rust)
 
-**Used by**: frontend-specialist, devops-specialist, opencoder, openimplementer
+**Used by**: frontend-specialist, devops-specialist, opencoder
 
 ### react-patterns.md
 Modern React patterns, hooks usage, and component design principles.
@@ -37,7 +37,7 @@ REST API design principles, GraphQL patterns, and API versioning strategies.
 - API versioning strategies
 - Authentication and authorization
 
-**Used by**: opencoder, openimplementer
+**Used by**: opencoder
 
 ## Usage
 
diff --git a/.opencode/context/development/api-design.md b/.opencode/context/development/api-design.md
index 9e6316d..e48e950 100644
--- a/.opencode/context/development/api-design.md
+++ b/.opencode/context/development/api-design.md
@@ -2,7 +2,7 @@
 
 **Category**: development  
 **Purpose**: REST API design principles, GraphQL patterns, and API versioning strategies  
-**Used by**: opencoder, openimplementer
+**Used by**: opencoder
 
 ---
 
diff --git a/.opencode/context/development/clean-code.md b/.opencode/context/development/clean-code.md
index 53f68ad..7189d05 100644
--- a/.opencode/context/development/clean-code.md
+++ b/.opencode/context/development/clean-code.md
@@ -2,7 +2,7 @@
 
 **Category**: development  
 **Purpose**: Core coding standards and best practices for writing clean, maintainable code  
-**Used by**: frontend-specialist, devops-specialist, opencoder, openimplementer
+**Used by**: frontend-specialist, devops-specialist, opencoder
 
 ---
 
diff --git a/.opencode/context/development/principles/api-design.md b/.opencode/context/development/principles/api-design.md
index a9cf75a..94c1585 100644
--- a/.opencode/context/development/principles/api-design.md
+++ b/.opencode/context/development/principles/api-design.md
@@ -2,7 +2,7 @@
 
 **Category**: development  
 **Purpose**: REST API design principles, GraphQL patterns, and API versioning strategies  
-**Used by**: opencoder, openimplementer
+**Used by**: opencoder
 
 ---
 
diff --git a/.opencode/context/development/principles/clean-code.md b/.opencode/context/development/principles/clean-code.md
index 53f68ad..7189d05 100644
--- a/.opencode/context/development/principles/clean-code.md
+++ b/.opencode/context/development/principles/clean-code.md
@@ -2,7 +2,7 @@
 
 **Category**: development  
 **Purpose**: Core coding standards and best practices for writing clean, maintainable code  
-**Used by**: frontend-specialist, devops-specialist, opencoder, openimplementer
+**Used by**: frontend-specialist, devops-specialist, opencoder
 
 ---
 
diff --git a/.opencode/context/openagents-repo/core-concepts/agents.md b/.opencode/context/openagents-repo/core-concepts/agents.md
index 0b05463..f05982e 100644
--- a/.opencode/context/openagents-repo/core-concepts/agents.md
+++ b/.opencode/context/openagents-repo/core-concepts/agents.md
@@ -72,7 +72,6 @@ Agents:
 Agents:
 - `frontend-specialist.md` - React, Vue, modern CSS
 - `devops-specialist.md` - CI/CD, deployment, infrastructure
-- `openimplementer.md` - Lightweight implementation (1-4 files, <60 min)
 
 **When to use**: Building applications, dev tasks
 
diff --git a/.opencode/context/openagents-repo/core-concepts/categories.md b/.opencode/context/openagents-repo/core-concepts/categories.md
index 4d89190..816b226 100644
--- a/.opencode/context/openagents-repo/core-concepts/categories.md
+++ b/.opencode/context/openagents-repo/core-concepts/categories.md
@@ -23,7 +23,6 @@ Categories are domain-based groupings that organize agents, context files, and t
 **Purpose**: Essential system agents (always available)
 
 **Agents**:
-- openagent, opencoder, openimplementer, system-builder
 
 **When to use**: System-level tasks, orchestration, coding (simple or complex)
 
@@ -100,7 +99,6 @@ evals/agents/{category}/        # Tests by category
 ├── 0-category.json             # Category metadata
 ├── openagent.md
 ├── opencoder.md
-└── openimplementer.md
 
 .opencode/agent/subagents/development/
 ├── 0-category.json             # Subagent category metadata
@@ -351,7 +349,6 @@ Loads: `.opencode/context/development/react-patterns.md`
 ├── core/
 │   ├── openagent.md
 │   ├── opencoder.md
-│   └── openimplementer.md
 ├── subagents/
 │   ├── development/
 │   │   ├── frontend-specialist.md
@@ -384,7 +381,6 @@ core/
 ├── 0-category.json
 ├── openagent.md
 ├── opencoder.md
-└── openimplementer.md
 ```
 
 ### Development Subagents
@@ -414,7 +410,6 @@ evals/agents/core/
 │   ├── config/config.yaml
 │   └── tests/smoke-test.yaml
 ├── opencoder/
-└── openimplementer/
 ```
 
 ---
diff --git a/.opencode/context/openagents-repo/core-concepts/registry.md b/.opencode/context/openagents-repo/core-concepts/registry.md
index 77c9aad..1d60a2d 100644
--- a/.opencode/context/openagents-repo/core-concepts/registry.md
+++ b/.opencode/context/openagents-repo/core-concepts/registry.md
@@ -163,7 +163,7 @@ ERROR: Missing dependency: subagent:nonexistent
 **Specialist Subagents** (8 in Developer profile):
 - frontend-specialist: React, Vue, CSS architecture
 - devops-specialist: CI/CD, infrastructure, deployment
-- openimplementer: Lightweight implementation (1-4 files, <60 min)
+
 - task-manager: Feature breakdown and planning
 - documentation: Create and update docs
 - coder-agent: Execute coding subtasks
diff --git a/.opencode/context/openagents-repo/guides/github-issues-workflow.md b/.opencode/context/openagents-repo/guides/github-issues-workflow.md
new file mode 100644
index 0000000..c36662a
--- /dev/null
+++ b/.opencode/context/openagents-repo/guides/github-issues-workflow.md
@@ -0,0 +1,471 @@
+# Guide: GitHub Issues and Project Board Workflow
+
+**Prerequisites**: Basic understanding of GitHub issues and projects  
+**Purpose**: Step-by-step workflow for managing issues and project board
+
+---
+
+## Overview
+
+This guide covers how to work with GitHub issues and the project board to track and process different requests, features, and improvements.
+
+**Project Board**: https://github.com/users/darrenhinde/projects/2/views/2
+
+**Time**: Varies by task
+
+---
+
+## Quick Commands Reference
+
+```bash
+# List issues
+gh issue list --repo darrenhinde/OpenAgentsControl
+
+# Create issue
+gh issue create --repo darrenhinde/OpenAgentsControl --title "Title" --body "Body" --label "label1,label2"
+
+# Add issue to project
+gh project item-add 2 --owner darrenhinde --url https://github.com/darrenhinde/OpenAgentsControl/issues/NUMBER
+
+# View issue
+gh issue view NUMBER --repo darrenhinde/OpenAgentsControl
+
+# Update issue
+gh issue edit NUMBER --repo darrenhinde/OpenAgentsControl --add-label "new-label"
+
+# Close issue
+gh issue close NUMBER --repo darrenhinde/OpenAgentsControl
+```
+
+---
+
+## Step 1: Creating Issues
+
+### Issue Types
+
+**Feature Request**
+- Labels: `feature`, `enhancement`
+- Include: Goals, key features, success criteria
+- Template: See "Feature Issue Template" below
+
+**Bug Report**
+- Labels: `bug`
+- Include: Steps to reproduce, expected vs actual behavior
+- Template: See "Bug Issue Template" below
+
+**Improvement**
+- Labels: `enhancement`, `framework`
+- Include: Current state, proposed improvement, impact
+
+**Question**
+- Labels: `question`
+- Include: Context, specific question, use case
+
+### Priority Labels
+
+- `priority-high` - Critical, blocking work
+- `priority-medium` - Important, not blocking
+- `priority-low` - Nice to have
+
+### Category Labels
+
+- `agents` - Agent system related
+- `framework` - Core framework changes
+- `evals` - Evaluation framework
+- `idea` - High-level proposal
+
+### Creating an Issue
+
+```bash
+# Basic issue
+gh issue create \
+  --repo darrenhinde/OpenAgentsControl \
+  --title "Add new feature X" \
+  --body "Description of feature" \
+  --label "feature,priority-medium"
+
+# Feature with detailed body
+gh issue create \
+  --repo darrenhinde/OpenAgentsControl \
+  --title "Build plugin system" \
+  --label "feature,framework,priority-high" \
+  --body "$(cat <<'EOF'
+## Overview
+Brief description
+
+## Goals
+- Goal 1
+- Goal 2
+
+## Key Features
+- Feature 1
+- Feature 2
+
+## Success Criteria
+- [ ] Criterion 1
+- [ ] Criterion 2
+EOF
+)"
+```
+
+---
+
+## Step 2: Adding Issues to Project Board
+
+### Add Single Issue
+
+```bash
+# Add issue to project
+gh project item-add 2 \
+  --owner darrenhinde \
+  --url https://github.com/darrenhinde/OpenAgentsControl/issues/NUMBER
+```
+
+### Add Multiple Issues
+
+```bash
+# Add issues 137-142 to project
+for i in {137..142}; do
+  gh project item-add 2 \
+    --owner darrenhinde \
+    --url https://github.com/darrenhinde/OpenAgentsControl/issues/$i
+done
+```
+
+### Verify Issues on Board
+
+```bash
+# View project items
+gh project item-list 2 --owner darrenhinde --format json | jq '.items[] | {title, status}'
+```
+
+---
+
+## Step 3: Processing Issues
+
+### Workflow States
+
+1. **Backlog** - New issues, not yet prioritized
+2. **Todo** - Prioritized, ready to work on
+3. **In Progress** - Currently being worked on
+4. **In Review** - PR submitted, awaiting review
+5. **Done** - Completed and merged
+
+### Moving Issues
+
+```bash
+# Update issue status (via project board UI or gh CLI)
+# Note: Status updates are typically done via web UI
+```
+
+### Assigning Issues
+
+```bash
+# Assign to yourself
+gh issue edit NUMBER \
+  --repo darrenhinde/OpenAgentsControl \
+  --add-assignee @me
+
+# Assign to someone else
+gh issue edit NUMBER \
+  --repo darrenhinde/OpenAgentsControl \
+  --add-assignee username
+```
+
+---
+
+## Step 4: Working on Issues
+
+### Start Work
+
+1. **Assign issue to yourself**
+   ```bash
+   gh issue edit NUMBER --repo darrenhinde/OpenAgentsControl --add-assignee @me
+   ```
+
+2. **Move to "In Progress"** (via web UI)
+
+3. **Create branch** (optional)
+   ```bash
+   git checkout -b feature/issue-NUMBER-description
+   ```
+
+4. **Reference issue in commits**
+   ```bash
+   git commit -m "feat: implement X (#NUMBER)"
+   ```
+
+### Update Progress
+
+```bash
+# Add comment to issue
+gh issue comment NUMBER \
+  --repo darrenhinde/OpenAgentsControl \
+  --body "Progress update: Completed X, working on Y"
+```
+
+### Complete Work
+
+1. **Create PR**
+   ```bash
+   gh pr create \
+     --repo darrenhinde/OpenAgentsControl \
+     --title "Fix #NUMBER: Description" \
+     --body "Closes #NUMBER\n\nChanges:\n- Change 1\n- Change 2"
+   ```
+
+2. **Move to "In Review"** (via web UI)
+
+3. **After merge, issue auto-closes** (if PR uses "Closes #NUMBER")
+
+---
+
+## Step 5: Using Issues for Request Processing
+
+### Request Types
+
+**User Feature Request**
+1. Create issue with `feature` label
+2. Add to project board
+3. Prioritize based on impact
+4. Break down into subtasks if needed
+5. Assign to appropriate person/team
+
+**Bug Report**
+1. Create issue with `bug` label
+2. Add reproduction steps
+3. Prioritize based on severity
+4. Assign for investigation
+5. Link to related issues if applicable
+
+**Improvement Suggestion**
+1. Create issue with `enhancement` label
+2. Discuss approach in comments
+3. Get consensus before implementation
+4. Create implementation plan
+5. Execute and track progress
+
+### Breaking Down Large Issues
+
+For complex features, create parent issue and subtasks:
+
+```bash
+# Parent issue
+gh issue create \
+  --repo darrenhinde/OpenAgentsControl \
+  --title "[EPIC] Plugin System" \
+  --label "feature,framework,priority-high" \
+  --body "Parent issue for plugin system work"
+
+# Subtask issues
+gh issue create \
+  --repo darrenhinde/OpenAgentsControl \
+  --title "Plugin manifest system" \
+  --label "feature" \
+  --body "Part of #PARENT_NUMBER\n\nImplement plugin.json manifest"
+```
+
+---
+
+## Step 6: Issue Templates
+
+### Feature Issue Template
+
+```markdown
+## Overview
+Brief description of the feature
+
+## Goals
+- Goal 1
+- Goal 2
+- Goal 3
+
+## Key Features
+- Feature 1
+- Feature 2
+- Feature 3
+
+## Related Issues
+- #123 (related issue)
+
+## Success Criteria
+- [ ] Criterion 1
+- [ ] Criterion 2
+- [ ] Criterion 3
+```
+
+### Bug Issue Template
+
+```markdown
+## Description
+Brief description of the bug
+
+## Steps to Reproduce
+1. Step 1
+2. Step 2
+3. Step 3
+
+## Expected Behavior
+What should happen
+
+## Actual Behavior
+What actually happens
+
+## Environment
+- OS: macOS/Linux/Windows
+- Version: 0.5.2
+- Node: v20.x
+
+## Additional Context
+Any other relevant information
+```
+
+### Improvement Issue Template
+
+```markdown
+## Current State
+Description of current implementation
+
+## Proposed Improvement
+What should be improved and why
+
+## Impact
+- Performance improvement
+- Developer experience
+- User experience
+
+## Implementation Approach
+High-level approach to implementation
+
+## Success Criteria
+- [ ] Criterion 1
+- [ ] Criterion 2
+```
+
+---
+
+## Step 7: Automation and Integration
+
+### Auto-Close Issues
+
+Use keywords in PR descriptions:
+- `Closes #123`
+- `Fixes #123`
+- `Resolves #123`
+
+### Link Issues to PRs
+
+```bash
+# In PR description
+gh pr create \
+  --title "Add feature X" \
+  --body "Implements #123\n\nChanges:\n- Change 1"
+```
+
+### Issue References in Commits
+
+```bash
+# Reference issue in commit
+git commit -m "feat: add plugin system (#137)"
+
+# Close issue in commit
+git commit -m "fix: resolve permission error (closes #140)"
+```
+
+---
+
+## Best Practices
+
+### Issue Creation
+
+✅ **Clear titles** - Descriptive and specific  
+✅ **Detailed descriptions** - Include context and goals  
+✅ **Proper labels** - Use consistent labeling  
+✅ **Success criteria** - Define what "done" means  
+✅ **Link related issues** - Show dependencies  
+
+### Issue Management
+
+✅ **Regular triage** - Review and prioritize weekly  
+✅ **Keep updated** - Add comments on progress  
+✅ **Close stale issues** - Clean up old/irrelevant issues  
+✅ **Use milestones** - Group related issues  
+✅ **Assign owners** - Clear responsibility  
+
+### Project Board
+
+✅ **Update status** - Keep board current  
+✅ **Limit WIP** - Don't overload "In Progress"  
+✅ **Review regularly** - Weekly board review  
+✅ **Archive completed** - Keep board clean  
+
+---
+
+## Common Workflows
+
+### Processing User Request
+
+1. **Receive request** (via issue, email, chat)
+2. **Create issue** with appropriate labels
+3. **Add to project board**
+4. **Triage and prioritize**
+5. **Assign to team member**
+6. **Track progress** via status updates
+7. **Review and merge** PR
+8. **Close issue** and notify requester
+
+### Planning New Feature
+
+1. **Create epic issue** for overall feature
+2. **Break down into subtasks**
+3. **Add all to project board**
+4. **Prioritize subtasks**
+5. **Assign to team members**
+6. **Track progress** across subtasks
+7. **Complete and close** when all subtasks done
+
+### Bug Triage
+
+1. **Create bug issue** with reproduction steps
+2. **Label with severity** (critical, high, medium, low)
+3. **Add to project board**
+4. **Assign for investigation**
+5. **Reproduce and diagnose**
+6. **Fix and test**
+7. **Create PR** with fix
+8. **Close issue** after merge
+
+---
+
+## Checklist
+
+Before closing an issue:
+
+- [ ] All success criteria met
+- [ ] Tests passing
+- [ ] Documentation updated
+- [ ] PR merged (if applicable)
+- [ ] Related issues updated
+- [ ] Stakeholders notified
+
+---
+
+## Related Files
+
+- **Registry guide**: `guides/updating-registry.md`
+- **Release guide**: `guides/creating-release.md`
+- **Testing guide**: `guides/testing-agent.md`
+- **Debugging**: `guides/debugging.md`
+
+---
+
+## External Resources
+
+- [GitHub Issues Documentation](https://docs.github.com/en/issues)
+- [GitHub Projects Documentation](https://docs.github.com/en/issues/planning-and-tracking-with-projects)
+- [GitHub CLI Documentation](https://cli.github.com/manual/)
+
+---
+
+**Last Updated**: 2026-01-30  
+**Version**: 0.5.2
diff --git a/.opencode/context/openagents-repo/guides/npm-publishing.md b/.opencode/context/openagents-repo/guides/npm-publishing.md
new file mode 100644
index 0000000..baba9c5
--- /dev/null
+++ b/.opencode/context/openagents-repo/guides/npm-publishing.md
@@ -0,0 +1,153 @@
+# NPM Publishing Guide
+
+**Purpose**: Quick reference for publishing OpenAgents Control to npm
+
+**Time to Read**: 3 minutes
+
+---
+
+## Core Concept
+
+OpenAgents Control is published as `@nextsystems/oac` on npm. Users install globally and run `oac [profile]` to set up their projects.
+
+**Key files**:
+- `package.json` - Package configuration
+- `bin/oac.js` - CLI entry point
+- `.npmignore` - Exclude dev files
+- `install.sh` - Main installer (runs when user executes `oac`)
+
+---
+
+## Publishing Workflow
+
+### 1. Prepare Release
+
+```bash
+# Update version
+npm version patch  # 0.7.0 -> 0.7.1
+npm version minor  # 0.7.0 -> 0.8.0
+
+# Update VERSION file
+node -p "require('./package.json').version" > VERSION
+
+# Update CHANGELOG.md with changes
+```
+
+### 2. Test Locally
+
+```bash
+# Create package
+npm pack
+
+# Install globally from tarball
+npm install -g ./nextsystems-oac-0.7.1.tgz
+
+# Test CLI
+oac --version
+oac --help
+
+# Uninstall
+npm uninstall -g @nextsystems/oac
+```
+
+### 3. Publish
+
+```bash
+# Login (one-time)
+npm login
+
+# Publish (scoped packages need --access public)
+npm publish --access public
+```
+
+### 4. Verify
+
+```bash
+# Check it's live
+npm view @nextsystems/oac
+
+# Test installation
+npm install -g @nextsystems/oac
+oac --version
+```
+
+### 5. Create GitHub Release
+
+```bash
+git tag v0.7.1
+git push --tags
+# Create release on GitHub with changelog
+```
+
+---
+
+## User Installation
+
+Once published, users can:
+
+```bash
+# Global install (recommended)
+npm install -g @nextsystems/oac
+oac developer
+
+# Or use npx (no install)
+npx @nextsystems/oac developer
+```
+
+---
+
+## Common Issues
+
+**"You do not have permission to publish"**
+```bash
+npm whoami  # Check you're logged in
+npm publish --access public  # Scoped packages need public access
+```
+
+**"Version already exists"**
+```bash
+npm version patch  # Bump version first
+```
+
+**"You must verify your email"**
+```bash
+npm profile get  # Check email verification status
+```
+
+---
+
+## Package Configuration
+
+**What's included** (see `package.json` → `files`):
+- `.opencode/` - Agents, commands, context, profiles, skills, tools
+- `scripts/` - Installation scripts
+- `bin/` - CLI entry point
+- `registry.json` - Component registry
+- `install.sh` - Main installer
+- Docs (README, CHANGELOG, LICENSE)
+
+**What's excluded** (see `.npmignore`):
+- `node_modules/`
+- `evals/`
+- `.tmp/`
+- Dev files
+
+---
+
+## Security
+
+- ✅ Enable 2FA: `npm profile enable-2fa auth-and-writes`
+- ✅ Use strong npm password
+- ✅ `@nextsystems` scope is protected (only you can publish)
+
+---
+
+## References
+
+- **Package**: https://www.npmjs.com/package/@nextsystems/oac
+- **Stats**: https://npm-stat.com/charts.html?package=@nextsystems/oac
+- **Codebase**: `package.json`, `bin/oac.js`, `.npmignore`
+
+---
+
+**Last Updated**: 2026-01-30
diff --git a/.opencode/context/openagents-repo/guides/profile-validation.md b/.opencode/context/openagents-repo/guides/profile-validation.md
index 6a8db89..7f1e0f5 100644
--- a/.opencode/context/openagents-repo/guides/profile-validation.md
+++ b/.opencode/context/openagents-repo/guides/profile-validation.md
@@ -97,7 +97,6 @@ cat registry.json | jq '.profiles.full.components[] | select(. == "agent:your-ag
 **Include**:
 - Core agents (openagent, opencoder)
 - Development specialist subagents (frontend, devops)
-- OpenImplementer (openimplementer - lightweight implementation agent)
 - All code subagents (tester, reviewer, coder-agent, build-agent)
 - Dev commands (commit, test, validate-repo, analyze-patterns)
 - Dev context (standards/code, standards/tests, workflows/*)
@@ -115,7 +114,7 @@ cat registry.json | jq '.profiles.full.components[] | select(. == "agent:your-ag
 - Content specialists (copywriter, technical-writer)
 - Data specialists (data-analyst)
 - Image tools (gemini, image-specialist)
-- Notification tools (telegram, notify)
+- Notification tools (notify)
 
 **Exclude**:
 - Development specialists
@@ -330,7 +329,7 @@ Add profile validation to CI:
 | data          | ❌        | ❌        | ✅       | ✅   | ✅       |
 | meta          | ❌        | ❌        | ❌       | ❌   | ✅       |
 
-*Note: Development category includes both agents (opencoder, openimplementer) and specialist subagents (frontend, devops)
+*Note: Development category includes agents (opencoder) and specialist subagents (frontend, devops)
 
 ---
 
diff --git a/.opencode/context/openagents-repo/lookup/file-locations.md b/.opencode/context/openagents-repo/lookup/file-locations.md
index 120be31..221dc47 100644
--- a/.opencode/context/openagents-repo/lookup/file-locations.md
+++ b/.opencode/context/openagents-repo/lookup/file-locations.md
@@ -120,11 +120,6 @@ README.md                            # Main documentation
 ```
 .opencode/agent/core/openagent.md
 .opencode/agent/core/opencoder.md
-```
-
-### Meta Agents
-
-```
 .opencode/agent/meta/system-builder.md
 ```
 
@@ -133,7 +128,9 @@ README.md                            # Main documentation
 ```
 .opencode/agent/development/frontend-specialist.md
 .opencode/agent/development/devops-specialist.md
-.opencode/agent/core/openimplementer.md
+```
+.opencode/agent/development/frontend-specialist.md
+.opencode/agent/development/devops-specialist.md
 ```
 
 ### Content Agents
diff --git a/.opencode/context/openagents-repo/navigation.md b/.opencode/context/openagents-repo/navigation.md
index 31bdd0a..bafbefd 100644
--- a/.opencode/context/openagents-repo/navigation.md
+++ b/.opencode/context/openagents-repo/navigation.md
@@ -2,7 +2,7 @@
 
 **Purpose**: Context files specific to the OpenAgents Control repository
 
-**Last Updated**: 2026-01-13
+**Last Updated**: 2026-01-30
 
 ---
 
@@ -12,7 +12,7 @@
 |----------|-------|---------|
 | **Concepts** | 2 files | Core ideas and principles |
 | **Examples** | 1 file | Working code samples |
-| **Guides** | 8 files | Step-by-step workflows |
+| **Guides** | 10 files | Step-by-step workflows |
 | **Lookup** | 4 files | Quick reference tables |
 | **Errors** | 1 file | Common issues + solutions |
 
@@ -46,6 +46,8 @@
 | `guides/adding-agent.md` | How to add new agents | ⭐⭐⭐⭐ |
 | `guides/testing-agent.md` | How to test agents | ⭐⭐⭐⭐ |
 | `guides/external-libraries-workflow.md` | How to handle external library dependencies | ⭐⭐⭐⭐ |
+| `guides/github-issues-workflow.md` | How to work with GitHub issues and project board | ⭐⭐⭐⭐ |
+| `guides/npm-publishing.md` | How to publish package to npm | ⭐⭐⭐ |
 | `guides/updating-registry.md` | How to update registry | ⭐⭐⭐ |
 | `guides/debugging.md` | How to debug issues | ⭐⭐⭐ |
 | `guides/resolving-installer-wildcard-failures.md` | Fix wildcard context install failures | ⭐⭐⭐ |
@@ -105,6 +107,12 @@
 4. Load `examples/subagent-prompt-structure.md` (if subagent)
 5. Load `guides/testing-agent.md` (validate)
 
+### For Issue Management:
+1. Load `guides/github-issues-workflow.md` (understand workflow)
+2. Create issues with proper labels and templates
+3. Add to project board for tracking
+4. Process requests systematically
+
 ### For Debugging:
 1. Load `guides/debugging.md` (general approach)
 2. Load specific error file from `errors/`
diff --git a/.opencode/plugin/telegram-notify.ts b/.opencode/plugin/telegram-notify.ts
deleted file mode 100644
index ac09ac6..0000000
--- a/.opencode/plugin/telegram-notify.ts
+++ /dev/null
@@ -1,104 +0,0 @@
-import type { Plugin } from "@opencode-ai/plugin"
-import { SimpleTelegramBot } from "../_lib/telegram-bot"
-
-// 🔧 CONFIGURATION: Set to true to enable this plugin
-const ENABLED = false
-
-export const TelegramNotify: Plugin = async ({ $ }) => {
-  // Plugin disabled - set ENABLED = true to activate
-  if (!ENABLED) return {}
-  
-  // Initialize Telegram bot
-  const bot = new SimpleTelegramBot()
-  let lastMessage = ""
-  
-  return {
-    async event(input) {
-      if (input.event.type === "session.idle") {
-        // Send the last message content along with idle notification
-        const message = lastMessage 
-          ? `🟡 Session idle! Here's your last message:\n\n${lastMessage}`
-          : "🟡 Hey! Your OpenCode session is idle - time to check your work!"
-        bot.sendMessage(message)
-      }
-      
-      if (input.event.type === "message.updated") {
-        // Reset idle timer when user sends messages
-        bot.resetActivity()
-        
-        const messageContent = (input.event as any).message?.content || 
-                              (input.event as any).content || ""
-        
-        // Check if it's a command to send last message
-        if (messageContent.includes("/send-last") || messageContent.includes("/last")) {
-          if (lastMessage) {
-            bot.sendMessage(`📱 Here's your last message:\n\n${lastMessage}`)
-          } else {
-            bot.sendMessage("📱 No previous message found.")
-          }
-          return
-        }
-        
-        // Check if it's a command to send to phone
-        if (messageContent.includes("/send-to-phone") || messageContent.includes("/phone")) {
-          if (lastMessage) {
-            bot.sendMessage(`📱 Sending to your phone:\n\n${lastMessage}`)
-          } else {
-            bot.sendMessage("📱 No message to send to phone.")
-          }
-          return
-        }
-        
-        // Try to capture message content from the event
-        try {
-          // Access message content if available
-          const messageContent = (input.event as any).message?.content || 
-                                (input.event as any).content ||
-                                "Message updated"
-          
-          if (messageContent && messageContent !== "Message updated") {
-            lastMessage = messageContent
-            
-            // Send a preview of the message to Telegram
-            const preview = lastMessage.length > 200 
-              ? lastMessage.substring(0, 200) + "..."
-              : lastMessage
-            
-            bot.sendMessage(`📱 Last message preview:\n\n${preview}`)
-          }
-        } catch (error) {
-          // If we can't access the message content, just log it
-          console.log("Message updated but couldn't capture content")
-        }
-      }
-      
-      if (input.event.type === "file.edited") {
-        // Reset idle timer when user edits files
-        bot.resetActivity()
-      }
-      
-      // Also listen for message parts being updated
-      if (input.event.type === "message.part.updated") {
-        bot.resetActivity()
-        
-        try {
-          const partContent = (input.event as any).part?.content || 
-                             (input.event as any).content ||
-                             "Message part updated"
-          
-          if (partContent && partContent !== "Message part updated") {
-            lastMessage = partContent
-            
-            const preview = lastMessage.length > 200 
-              ? lastMessage.substring(0, 200) + "..."
-              : lastMessage
-            
-            bot.sendMessage(`📱 Message part preview:\n\n${preview}`)
-          }
-        } catch (error) {
-          console.log("Message part updated but couldn't capture content")
-        }
-      }
-    }
-  }
-}
diff --git a/.opencode/profiles/advanced/profile.json b/.opencode/profiles/advanced/profile.json
index 804c928..26a23df 100644
--- a/.opencode/profiles/advanced/profile.json
+++ b/.opencode/profiles/advanced/profile.json
@@ -4,7 +4,6 @@
   "components": [
     "agent:openagent",
     "agent:opencoder",
-    "agent:openimplementer",
     "agent:system-builder",
     "agent:repo-manager",
     "agent:eval-runner",
diff --git a/.opencode/profiles/developer/profile.json b/.opencode/profiles/developer/profile.json
index 73f9d7e..8f96d32 100644
--- a/.opencode/profiles/developer/profile.json
+++ b/.opencode/profiles/developer/profile.json
@@ -1,10 +1,9 @@
 {
   "name": "Developer",
-  "description": "Complete software development environment with code generation, testing, review, and build tools. Choose OpenImplementer for focused tasks or OpenCoder for complex architecture. Recommended for most developers.",
+  "description": "Complete software development environment with code generation, testing, review, and build tools. Use OpenAgent for general tasks (1-4 files) or OpenCoder for complex architecture (4+ files). Recommended for most developers.",
   "badge": "RECOMMENDED",
   "components": [
     "agent:openagent",
-    "agent:openimplementer",
     "agent:opencoder",
     "subagent:task-manager",
     "subagent:frontend-specialist",
diff --git a/.opencode/profiles/full/profile.json b/.opencode/profiles/full/profile.json
index 7fdd390..78211da 100644
--- a/.opencode/profiles/full/profile.json
+++ b/.opencode/profiles/full/profile.json
@@ -4,7 +4,6 @@
   "components": [
     "agent:openagent",
     "agent:opencoder",
-    "agent:openimplementer",
     "agent:eval-runner",
     "agent:copywriter",
     "agent:technical-writer",
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 89317e6..daee8e0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -12,7 +12,7 @@ All notable changes to this project will be documented in this file.
 ### Documentation
 - Updated README.md and QUICK_START.md for v0.6.0 accuracy
   - Updated version from 0.1.0-alpha.1 to 0.6.0
-  - Added OpenImplementer agent to main agents list
+  - Simplified agent architecture (OpenAgent + OpenCoder)
   - Completed commands list with /analyze-patterns, /commit-openagents, /build-context-system
   - Highlighted ExternalScout with 18+ supported libraries
   - Updated installation profiles to mention new agents
diff --git a/README.md b/README.md
index 9262c09..8837eff 100644
--- a/README.md
+++ b/README.md
@@ -2,110 +2,323 @@
 
 ![OpenAgents Control Hero](docs/images/hero-image.png)
 
-# OpenAgents Control (AOC)
+# OpenAgents Control (OAC)
 
-### AI agent framework for plan-first development workflows with approval-based execution
+### Control your AI patterns. Get repeatable results. Zero refactoring.
+
+**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
 
-**Multi-language support:** TypeScript • Python • Go • Rust  
-**Features:** Automatic testing • Code review • Validation
 
 [![GitHub stars](https://img.shields.io/github/stars/darrenhinde/OpenAgentsControl?style=flat-square&logo=github&labelColor=black&color=ffcb47)](https://github.com/darrenhinde/OpenAgentsControl/stargazers)
 [![X Follow](https://img.shields.io/twitter/follow/DarrenBuildsAI?style=flat-square&logo=x&labelColor=black&color=1DA1F2)](https://x.com/DarrenBuildsAI)
 [![License: MIT](https://img.shields.io/badge/License-MIT-3fb950?style=flat-square&labelColor=black)](https://opensource.org/licenses/MIT)
 [![Last Commit](https://img.shields.io/github/last-commit/darrenhinde/OpenAgentsControl?style=flat-square&labelColor=black&color=8957e5)](https://github.com/darrenhinde/OpenAgentsControl/commits/main)
 
-[🚀 Quick Start](#get-started-in-5-minutes) • [📖 Documentation](#how-it-works) • [🎥 Demo Video](https://youtu.be/EOIzFMdmox8) • [💬 Community](https://nextsystems.ai)
+[🚀 Quick Start](#-quick-start) • [💻 Show Me Code](#-example-workflow) • [🗺️ Roadmap](https://github.com/darrenhinde/OpenAgentsControl/projects) • [💬 Community](https://nextsystems.ai)
 
 </div>
 
-## Why I Built This
+---
 
-I've spent 14+ years shipping production software. I've watched AI agents burn through thousands of tokens generating code that doesn't match your project, doesn't follow your patterns, and doesn't actually work without heavy refactoring.
-
-**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.
-
-**This system solves that**: AOC 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: **code that actually ships to production without heavy rework**.
-
-This isn't a gimmick project. I use this every day to ship real production code. It works because it respects two things:
-1. **Your time** - Agents propose plans, you approve before execution
-2. **Your patterns** - Agents follow your standards automatically
-
-**The result**: Production-ready code, not throwaway prototypes. No rework. No refactoring. Just ship.
-
-**Full-stack development**: AOC handles both frontend and backend work. No need for separate developers—the agents coordinate to build complete features from UI to database.
+> **Built on [OpenCode](https://opencode.ai)** - An open-source AI coding framework. OAC extends OpenCode with specialized agents, context management, and team workflows.
 
 ---
 
-## What Is AOC?
+## The Problem
 
-AOC is a **framework for AI-assisted development** that combines:
-- **Plan-first workflows** - Agents propose plans before implementing
-- **Context-aware execution** - Agents follow YOUR coding standards
-- **Incremental validation** - Step-by-step implementation with quality checks
+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.
 
-Think of it as having a senior developer who understands your project's patterns and asks for approval before making changes.
+**Example:**
+```typescript
+// What AI gives you (generic)
+export async function POST(request: Request) {
+  const data = await request.json();
+  return Response.json({ success: true });
+}
 
-**Key insight**: The context system (your coding standards) is the secret weapon. Agents automatically load and follow your patterns, so code is consistent without manual configuration.
+// 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 Navigation
+## 🆚 Quick Comparison
 
-- **New here?** → [What Is AOC?](#what-is-aoc) → [Get Started](#get-started-in-5-minutes)
-- **Want to understand the system?** → [How It Works](#how-it-works) → [Context System](#-the-context-system-your-secret-weapon)
-- **Ready to install?** → [Installation](#installation)
-- **Building something?** → [Example Workflows](#example-workflows)
+| Feature | OpenAgentsControl | Cursor/Copilot | Aider |
+|---------|-------------------|----------------|-------|
+| **Learn Your Patterns** | ✅ Built-in | ❌ No | ❌ No |
+| **Approval Gates** | ✅ Always | ❌ Auto-executes | ⚠️ Optional |
+| **Token Efficiency** | ✅ MVI principle | ❌ Standard | ❌ Standard |
+| **Team Standards** | ✅ Built-in | ❌ Per-user | ❌ No |
+| **Edit Agent Behavior** | ✅ Markdown files | ❌ Baked-in | ⚠️ Limited |
+| **Model Choice** | ✅ Any model | ❌ Vendor locked | ⚠️ OpenAI only |
+
+**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)
 
 ---
 
-## Why Use AOC?
+## 🚀 Quick Start
 
-- ✅ **Multi-language support** - Works with TypeScript, Python, Go, Rust, and more
-- ✅ **Plan-first workflow** - Agents propose plans before implementing
-- ✅ **Incremental execution** - Step-by-step implementation with validation
-- ✅ **Quality built-in** - Automatic testing, type checking, and code review
-- ✅ **Your patterns** - Agents follow your coding standards from context files
+**Prerequisites:** [OpenCode CLI](https://opencode.ai/docs) (free, open-source) • Bash 3.2+ • Git
 
----
+### Step 1: Install
 
-## Get Started in 5 Minutes
-
-**One command. That's it.**
+**One command:**
 
 ```bash
-# Quick install (developer profile)
 curl -fsSL https://raw.githubusercontent.com/darrenhinde/OpenAgentsControl/main/install.sh | bash -s developer
 ```
 
-**Or use interactive installer:**
-```bash
-# Download the installer
-curl -fsSL https://raw.githubusercontent.com/darrenhinde/OpenAgentsControl/main/install.sh -o install.sh
+<sub>The installer will set up OpenCode CLI if you don't have it yet.</sub>
 
-# Run interactively
+**Or interactive:**
+```bash
+curl -fsSL https://raw.githubusercontent.com/darrenhinde/OpenAgentsControl/main/install.sh -o install.sh
 bash install.sh
 ```
 
-Then start building:
+### Step 2: Start Building
+
 ```bash
 opencode --agent OpenAgent
 > "Create a user authentication system"
 ```
 
+### Step 3: Approve & Ship
+
 **What happens:**
-1. Analyzes your request
+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 the entire workflow.** No complex setup. No configuration. Just ship code.
+**That's it.** Works immediately with your default model. No configuration required.
 
 ---
 
-## Recommended for New Users
+## 💡 The Context System: Your Secret Weapon
 
-**Start with `OpenAgent`** - a lightweight, versatile agent perfect for getting started. It handles multiple task types and is ideal for learning the system.
+**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
+# 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
@@ -115,9 +328,17 @@ opencode --agent OpenAgent
 > "Explain the architecture of this codebase"      # Analysis
 ```
 
-OpenAgent is a streamlined version that can handle most tasks while you learn the workflow. It automatically delegates to specialists when needed.
+**What it does:**
+- Loads your patterns via ContextScout
+- Proposes plan (you approve)
+- Executes with validation
+- Delegates to specialists when needed
 
-**Ready for advanced workflows?** Upgrade to `OpenCoder`:
+**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
@@ -126,53 +347,371 @@ opencode --agent OpenCoder
 > "Add real-time notifications with WebSockets"         # Complex implementations
 ```
 
-OpenCoder is the full-featured development agent with rigorous workflows: Discover context → Propose plan → Get approval → Execute incrementally → Validate → Ship. It provides deeper context management, session tracking, and more sophisticated delegation to specialists (TaskManager, TestEngineer, CodeReviewer).
+**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
 
-**Learn more:** 
-- [OpenAgent Guide](docs/agents/openagent.md) - Lightweight, versatile agent for getting started
-- [OpenCoder Guide](docs/agents/opencoder.md) - Advanced development workflows
+**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
 
 ---
 
-## Installation
+## 🛠️ What's Included
 
-### Prerequisites
-- **OpenCode CLI** - [Install here](https://opencode.ai/docs)
-- **Bash 3.2+** (macOS default works)
-- **Git** (for cloning)
+### 🤖 Main Agents
+- **OpenAgent** - General tasks, questions, learning (start here)
+- **OpenCoder** - Production development, complex features
+- **SystemBuilder** - Generate custom AI systems
 
-### Install AOC
+### 🔧 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
 
-**Recommended: One-line install**
-```bash
-curl -fsSL https://raw.githubusercontent.com/darrenhinde/OpenAgentsControl/main/install.sh | bash -s developer
-```
+### ⚡ 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
 
-**Alternative: Interactive installer**
-```bash
-curl -fsSL https://raw.githubusercontent.com/darrenhinde/OpenAgentsControl/main/install.sh -o install.sh
-bash install.sh
-```
+### 📚 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
 
-**Manual install**
-```bash
-git clone https://github.com/darrenhinde/OpenAgentsControl.git
-cd OpenAgentsControl
-mkdir -p ~/.opencode
-cp -r .opencode/agent ~/.opencode/
-cp -r .opencode/command ~/.opencode/
-cp -r .opencode/context ~/.opencode/
-```
-
-### Start Using It
-```bash
-opencode --agent OpenAgent
-> "Create a user authentication system"
-```
+**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)
 
 ---
 
-## 🌟 Liking This Project?
+
+
+## 💻 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
+```
+
+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`
+
+**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: Global (`~/.opencode/`) works for most. Project-specific (`.opencode/`) if you need different configs per project.
+
+---
+
+## 🗺️ 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
 
 <div align="center">
 
@@ -191,355 +730,10 @@ opencode --agent OpenAgent
 
 ---
 
-## Setup & Installation FAQ
-
-**Q: Does this work on Windows?**  
-A: Yes! Use Git Bash (recommended) or WSL. See [Platform Compatibility Guide](docs/getting-started/platform-compatibility.md) for details.
-
-**Q: What bash version do I need?**  
-A: Bash 3.2+ (works on macOS default bash). Run `bash scripts/tests/test-compatibility.sh` to check your system.
-
-**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: Global (`~/.opencode/`) works for most. Project-specific (`.opencode/`) if you need different configs per project.
-
-**Q: How do I add my own coding patterns?**  
-A: Edit `~/.opencode/context/project/project-context.md` - agents automatically load this file.
-
-**Q: What languages are supported?**  
-A: The agents work with any language (TypeScript, Python, Go, Rust, etc.) and adapt based on your project files.
-
----
-
-## How It Works
-
-```
-User Request
-    ↓
-┌───────────────────────────────────────┐
-│  Main Agents (User-Facing)           │
-├───────────────────────────────────────┤
-│  openagent     │ General tasks        │
-│  opencoder     │ Complex coding       │
-│  system-builder│ AI system generation │
-└───────────────────────────────────────┘
-    ↓
-┌───────────────────────────────────────┐
-│  Specialized Subagents                │
-├───────────────────────────────────────┤
-│  Core:         task-manager, docs     │
-│  Code:         coder, tester, reviewer│
-│  Utils:        image-specialist       │
-│  Meta:         domain-analyzer, etc.  │
-└───────────────────────────────────────┘
-```
-
-**The workflow:**
-1. **You describe** what you want to build
-2. **Agent plans** the implementation steps
-3. **You approve** the plan
-4. **Agent implements** incrementally with validation
-5. **Quality checks** run automatically (tests, types, linting)
-6. **Subagents handle** specialized tasks (testing, review, docs)
-
-**Context-aware:** Agents automatically load patterns from `.opencode/context/` to follow your coding standards.
-
-**Smart discovery:** ContextScout finds relevant standards, ExternalScout fetches current library docs (preventing outdated training data issues). ExternalScout supports 18+ libraries including Drizzle, Better Auth, Next.js, TanStack, Cloudflare Workers, AWS Lambda, and more.
-
----
-
-## 🧠 The Context System (Your Secret Weapon)
-
-### What Is Context?
-
-Context files are **your project's coding standards and patterns**. They tell agents how you write code, what libraries you use, your security requirements, and your design system.
-
-**Think of it as a style guide for AI agents.**
-
-### How It Works
-
-```
-Your Request
-    ↓
-Agent receives request
-    ↓
-ContextScout discovers relevant context files
-    ↓
-Agent loads context files
-    ↓
-Agent follows patterns from context
-    ↓
-Code matches your standards automatically
-```
-
-### Why It Matters
-
-**Without context**: You ask for a component → Agent creates it in its own style → Doesn't match your project ❌
-
-**With context**: You ask for a component → Agent loads your patterns → Creates component matching your style → Perfectly matches your project ✅
-
-### Get Started
-
-1. **Add your patterns** to `~/.opencode/context/project/project-context.md`
-2. **Include examples** of your API endpoints, components, naming conventions
-3. **Agents automatically use** these patterns in all code they generate
-
-### Learn More
-
-For a complete guide including real-world examples and best practices, see [The Context System Guide](CONTEXT_SYSTEM_GUIDE.md).
-
----
-
-## What's Included
-
-### 🤖 Main Agents (3 core agents)
-- **OpenCoder** - Specialized development agent for production-ready code (start here for building)
-- **OpenAgent** - Universal coordinator for general tasks, questions, and workflows
-- **SystemBuilder** - Interactive tool for generating complete custom AI systems
-
-### 🔧 Specialized Subagents (Auto-delegated)
-- **task-manager** - Breaks complex features into atomic subtasks
-- **coder-agent** - Focused code implementations
-- **tester** - Test authoring and TDD
-- **reviewer** - Code review and security analysis
-- **build-agent** - Type checking and build validation
-- **documentation** - Documentation generation
-- Plus category specialists: frontend, devops, copywriter, technical-writer, data-analyst
-
-### ⚡ Commands
-- `/commit` - Smart git commits with conventional format
-- `/test` - Testing workflows
-- `/optimize` - Code optimization
-- `/context` - Context management
-- And 7+ more productivity commands
-
-### 📚 Context System
-Your coding standards automatically loaded by agents:
-- Code quality and security patterns
-- UI/design system standards
-- Task management workflows
-- External library integration guides
-- Your project-specific patterns
-
----
-
-## Example Workflows
-
-### Build a Full-Stack Feature
-```bash
-opencode --agent OpenCoder
-> "Create a user dashboard with authentication and profile settings"
-
-# OpenCoder will:
-# 1. Discover context (loads your auth patterns, code standards)
-# 2. Propose detailed implementation plan
-# 3. Wait for your approval
-# 4. Initialize session and persist context
-# 5. Delegate to task-manager (creates atomic task breakdown)
-#    - task-manager identifies UI and backend tasks
-#    - Suggests frontend-specialist for UI work
-#    - Includes design standards in context
-# 6. Frontend specialist executes 4-stage workflow:
-#    - Stage 1: Layout (ASCII wireframe, responsive structure)
-#    - Stage 2: Theme (design system, CSS theme file)
-#    - Stage 3: Animation (micro-interactions, timing)
-#    - Stage 4: Implementation (single HTML file, design_iterations/)
-# 7. Execute full-stack implementation (frontend + backend)
-# 8. Delegate to tester for tests and reviewer for security
-# 9. Validate and handoff production-ready code
-```
-
-### Build a Backend Feature
-```bash
-opencode --agent OpenCoder
-> "Create a user authentication system with email/password"
-
-# OpenCoder will:
-# 1. Discover context (loads auth-patterns.md, code-quality.md)
-# 2. Propose implementation plan with component breakdown
-# 3. Wait for your approval
-# 4. Initialize session (.tmp/sessions/YYYY-MM-DD-auth-system/)
-# 5. Delegate to task-manager for atomic task breakdown
-# 6. Execute incrementally (one component at a time)
-# 7. Validate after each step (type check, lint, test)
-# 8. Delegate to tester and reviewer
-# 9. Ship production-ready code
-```
-
-### Make a Commit
-```bash
-# Make your changes
-git add .
-
-# Use the commit command
-/commit
-
-# Auto-generates: ✨ feat: add user authentication system
-```
-
-### Add Your Patterns
-```bash
-# Edit your project context
-nano ~/.opencode/context/project/project-context.md
-
-# Add your patterns:
-# **API Endpoint Pattern:**
-# ```typescript
-# export async function POST(request: Request) {
-#   // Your standard pattern
-# }
-# ```
-
-# Agents will automatically use these patterns!
-```
-
----
-
-## Feature Deep Dives
-
-The following sections provide detailed information about advanced features. New users can skip to [Advanced Features FAQ](#advanced-features-faq) and return to these as needed.
-
----
-
-## 🎨 Frontend Design Workflow
-
-The **OpenFrontendSpecialist** follows a structured 4-stage design workflow for UI-heavy features:
-
-**4-Stage Process:**
-1. **Layout** - ASCII wireframe, responsive structure planning (mobile-first)
-2. **Theme** - Design system selection (Tailwind + Flowbite), OKLCH colors, typography
-3. **Animation** - Micro-interactions, timing (<400ms), accessibility (prefers-reduced-motion)
-4. **Implementation** - Single HTML file, semantic markup, saved to `design_iterations/`
-
-**Key Features:**
-- Approval gates at each stage
-- Design versioning (`design_1.html`, `design_1_1.html`, `design_2.html`)
-- Mobile-first responsive design (375px, 768px, 1024px, 1440px)
-- TaskManager auto-detects UI tasks and suggests OpenFrontendSpecialist
-
-**Learn more:** [Frontend Design Workflow Guide](docs/features/frontend-design-workflow.md)
-
----
-
-## 📋 Task Management & Breakdown
-
-The **TaskManager** breaks complex features into atomic, verifiable subtasks with smart agent suggestions and parallel execution support.
-
-**Key Capabilities:**
-- **Atomic Decomposition** - Tasks completable in 1-2 hours
-- **Dependency Tracking** - Explicit dependencies via `depends_on`
-- **Parallel Execution** - Frontend and backend work simultaneously
-- **Agent Suggestions** - Auto-recommends best agent (e.g., OpenFrontendSpecialist for UI)
-- **Context Boundaries** - Separates standards from source material
-- **CLI Integration** - Status tracking and validation
-
-**Workflow:**
-1. **Plan** - Analyzes feature and creates task breakdown
-2. **Suggest** - Recommends best agent for each task
-3. **Execute** - Agents work with clear context boundaries (parallel where possible)
-4. **Verify** - Validates completion against acceptance criteria
-5. **Track** - CLI shows progress and next available tasks
-
-**Learn more:** [Task Management Guide](docs/features/task-management.md)
-
----
-
-## 🏗️ System Builder (New!)
-
-**Build complete custom AI systems tailored to your domain in minutes.**
-
-The System Builder is an interactive tool that generates complete `.opencode` architectures customized to your needs.
-
-### Quick Start
-```bash
-# Install advanced profile (includes system builder)
-curl -fsSL https://raw.githubusercontent.com/darrenhinde/OpenAgentsControl/main/install.sh | bash -s advanced
-
-# Run the interactive builder
-/build-context-system
-```
-
-### What It Does
-- 🎯 **Interactive Interview** - Asks about your domain, use cases, and requirements
-- 🤖 **Generates Complete System** - Creates orchestrator, subagents, context files, workflows, and commands
-- 🔗 **Integrates with Existing** - Detects and reuses your existing agents
-- 🛡️ **Safe Merging** - Won't overwrite your work, offers merge strategies
-- 📚 **Production-Ready** - Includes documentation, testing guides, and examples
-
-### Example
-```bash
-$ /build-context-system
-
-Domain: E-commerce Operations
-Purpose: Automate order processing and customer support
-
-# After answering questions, generates:
-# - ecommerce-orchestrator (main agent)
-# - order-processor, ticket-router, report-generator (subagents)
-# - 12 context files (domain knowledge, processes, standards)
-# - 5 workflows (process-order, route-ticket, etc.)
-# - 5 custom commands (/process-order, /route-ticket, etc.)
-# - Complete documentation
-```
-
-**Learn more:** [System Builder Documentation](docs/features/system-builder/)
-
----
-
-## Advanced Features FAQ
-
-**Q: What's the main way to use this?**  
-A: Use `opencode --agent OpenCoder` for building features and production code. For general questions, documentation, or simple tasks, use `opencode --agent OpenAgent`. Both coordinate with specialists as needed.
-
-**Q: What's the Agent System Blueprint for?**  
-A: It's a teaching document explaining architecture patterns and how to extend the system. See [docs/features/agent-system-blueprint.md](docs/features/agent-system-blueprint.md)
-
-**Q: How does the frontend design workflow work?**  
-A: The frontend-specialist agent follows a 4-stage workflow: Layout (wireframe) → Theme (design system) → Animation (micro-interactions) → Implementation (HTML). Each stage has approval gates. See the [Frontend Design Workflow](#-frontend-design-workflow) section above.
-
-**Q: What's ExternalScout?**  
-A: ExternalScout fetches current documentation for external libraries (Tailwind, React, etc.) to prevent outdated training data issues. ContextScout uses it automatically when needed.
-
-**Q: How does task-manager suggest agents?**  
-A: The task-manager analyzes each task and sets a `suggested_agent` field. For UI tasks, it suggests frontend-specialist and includes design context files automatically.
-
-**Q: Can I use just one command or agent?**  
-A: Yes! Use the installer's list feature to see all components:
-```bash
-./install.sh --list
-```
-Or cherry-pick individual files with curl:
-```bash
-# Create category directory first
-mkdir -p ~/.opencode/agent/core
-
-# Download specific agent
-curl -o ~/.opencode/agent/core/opencoder.md \
-  https://raw.githubusercontent.com/darrenhinde/OpenAgentsControl/main/.opencode/agent/core/opencoder.md
-```
-
----
-
-## Contributing
-
-We welcome contributions! Please see our [Contributing Guide](docs/contributing/CONTRIBUTING.md) for details.
-
-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 also: [Code of Conduct](docs/contributing/CODE_OF_CONDUCT.md)
-
----
-
 ## License
 
 This project is licensed under the MIT License.
 
 ---
 
-**Made with ❤️ by developers, for developers. Star the repo if this helped you ship better code!**
-
+**Made with ❤️ by developers, for developers. Star the repo if this saves you refactoring time!**
diff --git a/bin/oac.js b/bin/oac.js
new file mode 100755
index 0000000..abc1752
--- /dev/null
+++ b/bin/oac.js
@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+
+/**
+ * OpenAgents Control (OAC) CLI
+ * 
+ * This is the main entry point for the @openagents/control package.
+ * It runs the install.sh script to set up the OpenAgents Control system.
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+// Get the package root directory
+const packageRoot = path.join(__dirname, '..');
+
+// Path to install.sh
+const installScript = path.join(packageRoot, 'install.sh');
+
+// Check if install.sh exists
+if (!fs.existsSync(installScript)) {
+  console.error('Error: install.sh not found at', installScript);
+  process.exit(1);
+}
+
+// Get command line arguments (skip node and script path)
+const args = process.argv.slice(2);
+
+// If no arguments provided, show help
+if (args.length === 0) {
+  console.log(`
+╔═══════════════════════════════════════════════════════════════╗
+║                  OpenAgents Control (OAC)                     ║
+║   AI agent framework for plan-first development workflows     ║
+╚═══════════════════════════════════════════════════════════════╝
+
+Usage:
+  oac [profile]           Install with a specific profile
+  oac --help             Show this help message
+  oac --version          Show version information
+
+Available Profiles:
+  essential              Minimal setup (OpenAgent only)
+  developer              Full development setup (recommended)
+  business               Business-focused agents
+  advanced               Advanced features and specialists
+  full                   Everything included
+
+Examples:
+  oac                    Interactive installation
+  oac developer          Install with developer profile
+  oac --help            Show detailed help
+
+For more information, visit:
+  https://github.com/darrenhinde/OpenAgentsControl
+`);
+  process.exit(0);
+}
+
+// Handle --version flag
+if (args.includes('--version') || args.includes('-v')) {
+  const packageJson = require(path.join(packageRoot, 'package.json'));
+  console.log(`@openagents/control v${packageJson.version}`);
+  process.exit(0);
+}
+
+// Handle --help flag
+if (args.includes('--help') || args.includes('-h')) {
+  // Run install.sh with --help
+  args.push('--help');
+}
+
+// Run the install script with bash
+const child = spawn('bash', [installScript, ...args], {
+  cwd: packageRoot,
+  stdio: 'inherit',
+  env: {
+    ...process.env,
+    OAC_PACKAGE_ROOT: packageRoot
+  }
+});
+
+child.on('error', (error) => {
+  console.error('Error running install script:', error.message);
+  process.exit(1);
+});
+
+child.on('exit', (code) => {
+  process.exit(code || 0);
+});
diff --git a/docs/README.md b/docs/README.md
index 221f897..ba654a2 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -99,9 +99,9 @@ docs/
 
 Latest updates:
 - ExternalScout subagent for fetching live library documentation (18+ libraries)
-- OpenImplementer agent for lightweight implementation tasks
 - Enhanced ContextScout with multi-model optimization
 - Complete command and agent documentation
+- Simplified agent architecture (OpenAgent + OpenCoder)
 
 ## 🤝 Community
 
diff --git a/package.json b/package.json
index 8bcd7b1..9b211fc 100644
--- a/package.json
+++ b/package.json
@@ -1,11 +1,41 @@
 {
-  "name": "opencode-agents",
+  "name": "@nextsystems/oac",
   "version": "0.7.0",
-  "description": "OpenCode agent evaluation framework and test suites",
-  "private": true,
+  "description": "AI agent framework for plan-first development workflows with approval-based execution. Multi-language support for TypeScript, Python, Go, Rust and more.",
   "workspaces": [
     "evals/framework"
   ],
+  "bin": {
+    "oac": "./bin/oac.js"
+  },
+  "files": [
+    ".opencode/agent/",
+    ".opencode/command/",
+    ".opencode/context/",
+    ".opencode/plugin/",
+    ".opencode/profiles/",
+    ".opencode/prompts/",
+    ".opencode/scripts/",
+    ".opencode/skill/",
+    ".opencode/tool/",
+    ".opencode/config.json",
+    ".opencode/opencode.json",
+    "!.opencode/tool/node_modules/",
+    "!.opencode/node_modules/",
+    "!**/node_modules/",
+    "scripts/",
+    "bin/",
+    "registry.json",
+    "install.sh",
+    "VERSION",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md",
+    "CONTEXT_SYSTEM_GUIDE.md"
+  ],
+  "engines": {
+    "node": ">=14.0.0"
+  },
   "scripts": {
     "test": "npm run test:all",
     "test:all": "cd evals/framework && npm run eval:sdk",
@@ -55,10 +85,18 @@
   },
   "keywords": [
     "opencode",
-    "agents",
-    "evaluation",
-    "testing",
-    "ai"
+    "openagents",
+    "ai-agents",
+    "code-generation",
+    "development-workflow",
+    "plan-first",
+    "context-aware",
+    "typescript",
+    "python",
+    "go",
+    "rust",
+    "cli",
+    "automation"
   ],
   "author": "Darren Hinde",
   "license": "MIT",
@@ -66,6 +104,10 @@
     "type": "git",
     "url": "https://github.com/darrenhinde/OpenAgentsControl.git"
   },
+  "bugs": {
+    "url": "https://github.com/darrenhinde/OpenAgentsControl/issues"
+  },
+  "homepage": "https://github.com/darrenhinde/OpenAgentsControl#readme",
   "devDependencies": {
     "glob": "^13.0.0"
   }
diff --git a/registry.json b/registry.json
index 58e3d55..619fc70 100644
--- a/registry.json
+++ b/registry.json
@@ -40,24 +40,6 @@
         ],
         "category": "core"
       },
-      {
-        "id": "openimplementer",
-        "name": "OpenImplementer",
-        "type": "agent",
-        "path": ".opencode/agent/core/openimplementer.md",
-        "description": "Lightweight implementation agent for focused coding tasks with direct execution, self-testing, and specialist review",
-        "tags": [
-          "implementation",
-          "focused-tasks",
-          "direct-execution",
-          "lightweight"
-        ],
-        "dependencies": [
-          "subagent:contextscout",
-          "subagent:reviewer"
-        ],
-        "category": "core"
-      },
       {
         "id": "openagent",
         "name": "OpenAgent",
@@ -671,37 +653,6 @@
       }
     ],
     "plugins": [
-      {
-        "id": "telegram-bot",
-        "name": "Telegram Bot Library",
-        "type": "plugin",
-        "path": ".opencode/_lib/telegram-bot.ts",
-        "description": "Simple Telegram Bot wrapper for sending notifications",
-        "tags": [
-          "telegram",
-          "bot",
-          "library"
-        ],
-        "dependencies": [],
-        "category": "specialized"
-      },
-      {
-        "id": "telegram-notify",
-        "name": "Telegram Notifications",
-        "type": "plugin",
-        "path": ".opencode/plugin/telegram-notify.ts",
-        "description": "Send notifications via Telegram bot",
-        "tags": [
-          "notifications",
-          "telegram",
-          "integration"
-        ],
-        "dependencies": [
-          "tool:env",
-          "plugin:telegram-bot"
-        ],
-        "category": "specialized"
-      },
       {
         "id": "notify",
         "name": "Generic Notifier",
@@ -2822,11 +2773,10 @@
     },
     "developer": {
       "name": "Developer",
-      "description": "Complete software development environment with code generation, testing, review, and build tools. Choose OpenImplementer for focused tasks or OpenCoder for complex architecture. Recommended for most developers.",
+      "description": "Complete software development environment with code generation, testing, review, and build tools. Use OpenAgent for general tasks (1-4 files) or OpenCoder for complex architecture (4+ files). Recommended for most developers.",
       "badge": "RECOMMENDED",
       "components": [
         "agent:openagent",
-        "agent:openimplementer",
         "agent:opencoder",
         "subagent:task-manager",
         "subagent:frontend-specialist",
@@ -2876,8 +2826,6 @@
         "tool:env",
         "tool:gemini",
         "plugin:notify",
-        "plugin:telegram-bot",
-        "plugin:telegram-notify",
         "context:essential-patterns",
         "context:project-context",
         "context:quick-start",
@@ -2894,7 +2842,6 @@
       "description": "Everything included - all agents, subagents, tools, and plugins for maximum functionality.",
       "components": [
         "agent:openagent",
-        "agent:openimplementer",
         "agent:opencoder",
         "agent:eval-runner",
         "agent:copywriter",
@@ -2923,8 +2870,6 @@
         "tool:env",
         "tool:gemini",
         "plugin:notify",
-        "plugin:telegram-bot",
-        "plugin:telegram-notify",
         "context:essential-patterns",
         "context:project-context",
         "context:quick-start",
@@ -2941,7 +2886,6 @@
       "description": "Full installation plus System Builder for creating custom AI architectures. For power users and contributors.",
       "components": [
         "agent:openagent",
-        "agent:openimplementer",
         "agent:opencoder",
         "agent:system-builder",
         "agent:repo-manager",
@@ -2979,8 +2923,6 @@
         "tool:env",
         "tool:gemini",
         "plugin:notify",
-        "plugin:telegram-bot",
-        "plugin:telegram-notify",
         "context:essential-patterns",
         "context:project-context",
         "context:quick-start",