diff --git a/.agent/reviews/agent-swarm-review-2026-01-21.md b/.agent/reviews/agent-swarm-review-2026-01-21.md
new file mode 100644
index 0000000..a25238a
--- /dev/null
+++ b/.agent/reviews/agent-swarm-review-2026-01-21.md
@@ -0,0 +1,238 @@
+# Review: Elisha Agent Swarm Security and Robustness
+
+**Version**: 1.0
+**Last Updated**: 2026-01-21T00:00:00Z
+**Last Agent**: reviewer
+**Status**: Open
+**Target**: src/permission/, src/mcp/hooks.ts, src/util/hooks.ts, src/task/, src/agent/
+**Scope**: standard
+
+## Summary
+
+**Files**: 15+ files reviewed across permission, mcp, task, util, and agent domains
+**Issues**: 2 critical, 4 warnings, 3 nitpicks
+
+---
+
+## Issues
+
+### Critical
+
+| File | Line | Issue | Confidence | Suggestion |
+|------|------|-------|------------|------------|
+| `src/permission/defaults.ts` | 16-24 | Bash command denylist is easily bypassed with variations (e.g., `rm -r -f`, `\rm`, `$(rm)`, backticks, pipes) | Definite | Consider allowlist approach or integrate with shell parser; current patterns are trivially circumvented |
+| `src/mcp/hooks.ts` | 21-27 | Suspicious pattern detection is incomplete and easily bypassed (case variations, unicode, obfuscation) | Likely | Expand pattern list, add unicode normalization, or document this as defense-in-depth only |
+
+### Warnings
+
+| File | Line | Issue | Confidence | Suggestion |
+|------|------|-------|------------|------------|
+| `src/instruction/hooks.ts` | 8 | Session tracking uses unbounded `Set<string>` with no TTL cleanup | Definite | Add TTL-based cleanup like `src/mcp/hooks.ts` and `src/task/hooks.ts` do |
+| `src/task/tools.ts` | 13 | `activeTasks` Set is module-level singleton - won't work correctly across multiple plugin instances | Likely | Consider using session-scoped or context-scoped storage |
+| `src/agent/researcher/index.ts` | 3 | Uses tilde import alias `~/mcp/chrome-devtools.ts` inconsistent with other files using relative paths | Definite | Use relative import `../../mcp/chrome-devtools.ts` for consistency |
+| `src/agent/util/index.ts` | 24 | Checks `config?.disabled` but agents use `config?.disable` (without 'd') | Definite | Change to `config?.disable !== true` to match actual property name |
+
+### Nitpicks
+
+| File | Line | Issue | Confidence | Suggestion |
+|------|------|-------|------------|------------|
+| `src/mcp/hooks.ts` | 48-49 | Magic numbers for SESSION_TTL_MS and MAX_SESSIONS duplicated in task/hooks.ts | Potential | Extract to shared constants in util/ |
+| `src/util/hooks.ts` | 8-24 | `runHooksWithIsolation` logs errors but doesn't include hook name for debugging | Potential | Include hook type in error message for easier debugging |
+| `src/agent/util/protocol/index.ts` | 20 | `expandProtocols` throws on unknown protocol but doesn't validate at build time | Potential | Consider compile-time validation or graceful fallback with warning |
+
+---
+
+## Detailed Analysis
+
+### 1. Security: Permission System
+
+**Location**: `src/permission/`
+
+**Strengths**:
+
+- Layered permission model (global → agent → tool)
+- Uses `defu` for proper config merging
+- Denies sensitive file reads (`.env*`)
+- Requires `ask` for external operations (webfetch, websearch)
+
+**Concerns**:
+
+1. **Bash Denylist Bypass (Critical)**: The patterns in `defaults.ts:16-24` are trivially bypassed:
+
+   ```typescript
+   bash: {
+     '*': 'allow',
+     'rm * /': 'deny',      // Bypassed by: rm -r -f /, \rm /, $(rm -rf /)
+     'rm -rf *': 'deny',    // Bypassed by: rm -r -f, rm --recursive --force
+     // ...
+   }
+   ```
+
+   Shell command matching via glob patterns cannot reliably prevent dangerous commands.
+
+2. **No Path Traversal Protection**: The `read` permission allows `*` but only denies `.env*`. Attackers could read `/etc/passwd`, `~/.ssh/id_rsa`, etc. if `external_directory` is allowed.
+
+### 2. Security: Memory Validation
+
+**Location**: `src/mcp/hooks.ts`
+
+**Strengths**:
+
+- Wraps memory content in `<untrusted-memory>` tags
+- Strips HTML comments that could hide instructions
+- Detects some suspicious imperative patterns
+- Applies validation to both initial injection and query results
+
+**Concerns**:
+
+1. **Pattern Detection Bypass (Critical)**: The suspicious patterns are easily bypassed:
+
+   ```typescript
+   const suspiciousPatterns = [
+     /ignore previous/i,    // Bypassed: "1gnore prev1ous", "ignore\u200Bprevious"
+     /execute/i,            // Too broad (matches "execute" in legitimate code)
+     // ...
+   ];
+   ```
+
+   This provides false sense of security. Consider documenting as defense-in-depth only.
+
+2. **No Content Length Limit**: Large memory payloads could cause context overflow or performance issues.
+
+### 3. Robustness: Error Handling in Hooks
+
+**Location**: `src/util/hooks.ts`
+
+**Strengths**:
+
+- Uses `Promise.allSettled` for isolation - one failing hook doesn't crash others
+- Logs errors with context
+- Covers all hook types
+
+**Concerns**:
+
+1. **Error Context**: Logged errors don't include which hook type failed, making debugging harder.
+
+2. **No Return Value Handling**: Some hooks may return values that need merging; current implementation discards all returns.
+
+### 4. Robustness: Task Concurrency and TTL
+
+**Location**: `src/task/`
+
+**Strengths**:
+
+- Concurrency limit (MAX_CONCURRENT_TASKS = 5)
+- Exponential backoff for polling
+- Proper cleanup in finally blocks
+- Session TTL cleanup (24 hours)
+
+**Concerns**:
+
+1. **Module-Level Singleton**: `activeTasks` Set is module-scoped. If plugin is instantiated multiple times, they share state incorrectly.
+
+2. **Race Condition**: Between checking `activeTasks.size` and adding to set, another task could be added.
+
+3. **No Task Timeout Enforcement**: While `waitForTask` has timeout, the task itself can run indefinitely.
+
+### 5. Robustness: Config Merging
+
+**Location**: Throughout codebase
+
+**Strengths**:
+
+- Consistent use of `defu` for config merging
+- Proper null coalescing (`ctx.config.agent ??= {}`)
+- User overrides preserved correctly
+
+**Concerns**:
+
+1. **Property Name Mismatch**: `src/agent/util/index.ts:24` checks `disabled` but agents use `disable`:
+
+   ```typescript
+   .filter(([_, config]) => config?.disabled !== true)  // Wrong property!
+   ```
+
+   Should be `config?.disable !== true`.
+
+### 6. Code Quality: Import Consistency
+
+**Location**: Throughout codebase
+
+**Strengths**:
+
+- Most files use `.ts` extensions correctly
+- Barrel exports used appropriately
+
+**Concerns**:
+
+1. **Tilde Import Alias**: `src/agent/researcher/index.ts:3` uses `~/mcp/chrome-devtools.ts` while all other files use relative paths. This inconsistency could cause issues.
+
+### 7. Code Quality: Synthetic Message Marking
+
+**Location**: All hook files
+
+**Strengths**:
+
+- All injected messages properly marked with `synthetic: true`
+- Consistent pattern across mcp/hooks.ts, task/hooks.ts, instruction/hooks.ts
+
+### 8. Code Quality: Hook Isolation
+
+**Location**: `src/instruction/hooks.ts`
+
+**Concerns**:
+
+1. **Unbounded Session Set**: Unlike mcp/hooks.ts and task/hooks.ts which have TTL cleanup, instruction/hooks.ts uses a plain `Set<string>` that grows unbounded:
+
+   ```typescript
+   const injectedSessions = new Set<string>();  // No cleanup!
+   ```
+
+   This is a memory leak for long-running processes.
+
+---
+
+## Actionable Items
+
+Tasks for executor to address (Critical and Warning issues):
+
+- [ ] `src/permission/defaults.ts:16-24` - Document bash denylist limitations; consider allowlist or shell parsing approach
+- [ ] `src/mcp/hooks.ts:21-27` - Document pattern detection as defense-in-depth; add content length limit
+- [ ] `src/instruction/hooks.ts:8` - Add TTL-based cleanup matching mcp/hooks.ts pattern
+- [ ] `src/task/tools.ts:13` - Consider session-scoped storage for activeTasks
+- [ ] `src/agent/researcher/index.ts:3` - Change tilde import to relative path
+- [ ] `src/agent/util/index.ts:24` - Fix property name from `disabled` to `disable`
+
+---
+
+## Security Recommendations
+
+### Short-term (High Priority)
+
+1. **Document Bash Limitations**: Add clear documentation that bash denylist is not a security boundary - it's defense-in-depth only. The real protection is the `ask` permission for dangerous operations.
+
+2. **Fix Property Name Bug**: The `disabled` vs `disable` mismatch could cause agents to appear in lists when they shouldn't.
+
+3. **Add Memory Leak Fix**: The instruction hooks session tracking will grow unbounded.
+
+### Medium-term
+
+1. **Consider Shell Parsing**: For bash restrictions, consider using a proper shell parser to normalize commands before matching.
+
+2. **Add Content Limits**: Memory content should have size limits to prevent context overflow attacks.
+
+3. **Improve Error Context**: Include hook type in error logs for easier debugging.
+
+### Long-term
+
+1. **Allowlist Approach**: Consider moving from denylist to allowlist for bash commands, especially for sensitive agents.
+
+2. **Formal Security Audit**: The prompt injection mitigations are good defense-in-depth but shouldn't be relied upon as primary security controls.
+
+---
+
+## Resolution Log
+
+| Version | Agent | Action | Timestamp |
+|---------|-------|--------|-----------|
+| 1.0 | reviewer | Initial security and robustness review | 2026-01-21T00:00:00Z |
diff --git a/.changeset/improved-agent-descriptions.md b/.changeset/improved-agent-descriptions.md
new file mode 100644
index 0000000..49335f4
--- /dev/null
+++ b/.changeset/improved-agent-descriptions.md
@@ -0,0 +1,13 @@
+---
+"@spiritledsoftware/elisha": minor
+---
+
+Improve agent descriptions and streamline prompts for better delegation
+
+- Enhanced all agent descriptions with "Use when:" guidance to help orchestrator make better delegation decisions
+- Added description to compaction agent (was previously missing)
+- Streamlined agent prompts by extracting shared protocols into reusable templates
+- Removed tester agent (consolidated into executor/reviewer workflows)
+- Refactored hook files from plural to singular naming convention (hooks.ts → hook.ts)
+- Consolidated task tools into single file with types
+- Simplified protocol templates for context-handling, error-handling, escalation, and plan-versioning
diff --git a/AGENTS.md b/AGENTS.md
index f4834cf..acf89c2 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -61,10 +61,10 @@ import PROMPT from "./prompt.md";
 
 Shared prompt sections use mustache syntax. Available protocols:
 
-- `{{protocol:context-handling}}`
-- `{{protocol:error-handling}}`
-- `{{protocol:escalation}}`
-- `{{protocol:plan-versioning}}`
+- `{{protocols:context-handling}`
+- `{{protocols:error-handling}`
+- `{{protocols:escalation}`
+- `{{protocols:plan-versioning}`
 
 ```typescript
 import { expandProtocols } from '../agent/util/protocol/index.ts';
diff --git a/biome.json b/biome.json
index d4c18f6..4613ca1 100644
--- a/biome.json
+++ b/biome.json
@@ -16,7 +16,10 @@
   "linter": {
     "enabled": true,
     "rules": {
-      "recommended": true
+      "recommended": true,
+      "correctness": {
+        "noUnusedImports": { "level": "warn", "fix": "safe" }
+      }
     }
   },
   "javascript": {
diff --git a/bun.lock b/bun.lock
index a4261b2..287a993 100644
--- a/bun.lock
+++ b/bun.lock
@@ -87,9 +87,9 @@
 
     "@nodelib/fs.walk": ["@nodelib/fs.walk@1.2.8", "", { "dependencies": { "@nodelib/fs.scandir": "2.1.5", "fastq": "^1.6.0" } }, "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg=="],
 
-    "@opencode-ai/plugin": ["@opencode-ai/plugin@1.1.27", "", { "dependencies": { "@opencode-ai/sdk": "1.1.27", "zod": "4.1.8" } }, "sha512-EevLVaEhQ1jTLNRbQJj18tFZaVNJcZZcVqvZEbDSe17CfmVRv3FQNKRAjD/QHwb+Kym7sn+LAZxD7aYIPPelvQ=="],
+    "@opencode-ai/plugin": ["@opencode-ai/plugin@1.1.29", "", { "dependencies": { "@opencode-ai/sdk": "1.1.29", "zod": "4.1.8" } }, "sha512-v70pQH//oN8Vd9KOZIpxIxrldKF4csmn799RS72WI7MGhMGTeuqrx/DUEqgqZePX9Kr6kKHN37fzug6KBJoWsQ=="],
 
-    "@opencode-ai/sdk": ["@opencode-ai/sdk@1.1.27", "", {}, "sha512-ssRZpET3zUNdk1GuF6HwFkNHhCXSTG0lhuPmw9HjifTwv1EVrn8gz7jAuME2OCvUSBvRTesH6Lb0Xt78Qbhzww=="],
+    "@opencode-ai/sdk": ["@opencode-ai/sdk@1.1.29", "", {}, "sha512-yLueXZ7deMtvDwfaRLBYkbNfFXqx4LrsW8P97NjzX4G7n5esme8l24Xu9lAU6dE2VcZsBcsz++hI5X0HT4sIUQ=="],
 
     "@types/bun": ["@types/bun@1.3.6", "", { "dependencies": { "bun-types": "1.3.6" } }, "sha512-uWCv6FO/8LcpREhenN1d1b6fcspAB+cefwD7uti8C8VffIv0Um08TKMn98FynpTiU38+y2dUO55T11NgDt8VAA=="],
 
diff --git a/package.json b/package.json
index 665dd74..e106f8f 100644
--- a/package.json
+++ b/package.json
@@ -36,8 +36,8 @@
     "prepare": "husky"
   },
   "dependencies": {
-    "@opencode-ai/plugin": "1.1.27",
-    "@opencode-ai/sdk": "^1.1.27",
+    "@opencode-ai/plugin": "1.1.29",
+    "@opencode-ai/sdk": "^1.1.29",
     "dedent": "^1.7.1",
     "defu": "^6.1.4",
     "nanoid": "^5.1.6"
diff --git a/src/agent/AGENTS.md b/src/agent/AGENTS.md
index a2249ea..9ecc8f0 100644
--- a/src/agent/AGENTS.md
+++ b/src/agent/AGENTS.md
@@ -33,18 +33,17 @@ agent/
 ### 2. Write the Configuration (`index.ts`)
 
 ```typescript
-import type { AgentConfig } from '@opencode-ai/sdk/v2';
-import defu from 'defu';
-import type { ElishaConfigContext } from '../..';
-import { setupAgentPermissions } from '../../permission/agent.ts';
-import { expandProtocols } from '../util/protocol/index.ts';
-
-import PROMPT from './prompt.md';
+import type { AgentConfig } from "@opencode-ai/sdk/v2";
+import defu from "defu";
+import type { ElishaConfigContext } from "../..";
+import { setupAgentPermissions } from "../../permission/agent.ts";
+import { expandProtocols } from "../util/protocol/index.ts";
+import PROMPT from "./prompt.md";
 
-export const AGENT_MY_AGENT_ID = 'my-agent';
+export const AGENT_MY_AGENT_ID = "my-agent";
 
 const getDefaults = (ctx: ElishaConfigContext): AgentConfig => ({
-  mode: 'subagent',               // 'primary', 'all', or 'subagent'
+  mode: "subagent", // 'primary', 'all', or 'subagent'
   hidden: false,
   model: ctx.config.model,
   temperature: 0.5,
@@ -52,12 +51,12 @@ const getDefaults = (ctx: ElishaConfigContext): AgentConfig => ({
     AGENT_MY_AGENT_ID,
     {
       // Agent-specific permission overrides
-      edit: 'deny',
-      webfetch: 'ask',
+      edit: "deny",
+      webfetch: "ask",
     },
-    ctx,
+    ctx
   ),
-  description: 'Brief description for Task tool selection...',
+  description: "Brief description for Task tool selection...",
   prompt: expandProtocols(PROMPT),
 });
 
@@ -65,7 +64,7 @@ export const setupMyAgentConfig = (ctx: ElishaConfigContext) => {
   ctx.config.agent ??= {};
   ctx.config.agent[AGENT_MY_AGENT_ID] = defu(
     ctx.config.agent?.[AGENT_MY_AGENT_ID] ?? {},
-    getDefaults(ctx),
+    getDefaults(ctx)
   );
 };
 ```
@@ -73,7 +72,7 @@ export const setupMyAgentConfig = (ctx: ElishaConfigContext) => {
 ### 3. Register in `index.ts`
 
 ```typescript
-import { setupMyAgentConfig } from './my-agent/index.ts';
+import { setupMyAgentConfig } from "./my-agent/index.ts";
 
 export const setupAgentConfig = (ctx: ElishaConfigContext) => {
   // ... existing agents
@@ -83,10 +82,10 @@ export const setupAgentConfig = (ctx: ElishaConfigContext) => {
 
 ## Agent Modes
 
-| Mode | Usage |
-|------|-------|
-| `primary` | Main agent (orchestrator). Set as `default_agent`. |
-| `all` | Core agents (planner, executor, reviewer) available via Task tool. |
+| Mode       | Usage                                                                               |
+| ---------- | ----------------------------------------------------------------------------------- |
+| `primary`  | Main agent (orchestrator). Set as `default_agent`.                                  |
+| `all`      | Core agents (planner, executor, reviewer) available via Task tool.                  |
 | `subagent` | Helper agents (explorer, researcher, architect, documenter) with specialized roles. |
 
 ## Protocol Expansion
@@ -95,15 +94,16 @@ Shared prompt sections live in `util/protocol/`. Use mustache syntax in prompts:
 
 ```markdown
 ## Error Handling
-{{protocol:error-handling}}
+
+{{protocols:error-handling}
 ```
 
 Available protocols:
 
-- `{{protocol:context-handling}}` - How to handle provided context
-- `{{protocol:error-handling}}` - Error handling patterns
-- `{{protocol:escalation}}` - When/how to escalate
-- `{{protocol:plan-versioning}}` - Plan version management
+- `{{protocols:context-handling}` - How to handle provided context
+- `{{protocols:error-handling}` - Error handling patterns
+- `{{protocols:escalation}` - When/how to escalate
+- `{{protocols:plan-versioning}` - Plan version management
 
 Expand in `index.ts`:
 
@@ -135,30 +135,30 @@ Permission values: `'allow'`, `'deny'`, `'ask'`
 
 ## Existing Agents
 
-| Agent | Mode | Purpose |
-|-------|------|---------|
-| `orchestrator` | `primary` | Task coordinator, delegates all work |
-| `planner` | `all` | Creates implementation plans |
-| `executor` | `all` | Implements plan tasks |
-| `reviewer` | `all` | Code review (read-only) |
-| `brainstormer` | `all` | Creative ideation |
-| `explorer` | `subagent` | Codebase search (read-only) |
-| `researcher` | `subagent` | External research |
-| `architect` | `subagent` | Solution design (no code) |
-| `designer` | `subagent` | Frontend/UX design specialist |
-| `tester` | `subagent` | Test execution and analysis |
-| `documenter` | `subagent` | Documentation writing |
-| `compaction` | `subagent` | Session compaction |
+| Agent          | Mode       | Purpose                                               |
+| -------------- | ---------- | ----------------------------------------------------- |
+| `orchestrator` | `primary`  | Task coordinator, delegates all work                  |
+| `planner`      | `all`      | Creates implementation plans                          |
+| `executor`     | `all`      | Implements plan tasks                                 |
+| `reviewer`     | `all`      | Code review (read-only)                               |
+| `brainstormer` | `all`      | Creative ideation                                     |
+| `explorer`     | `subagent` | Codebase search (read-only)                           |
+| `researcher`   | `subagent` | External research                                     |
+| `architect`    | `subagent` | Expert consultant + solution design (call when stuck) |
+| `designer`     | `subagent` | Frontend/UX design specialist                         |
+| `tester`       | `subagent` | Test execution and analysis                           |
+| `documenter`   | `subagent` | Documentation writing                                 |
+| `compaction`   | `subagent` | Session compaction                                    |
 
 ## Disabling Built-in Agents
 
 The `index.ts` disables some default OpenCode agents to avoid conflicts:
 
 ```typescript
-disableAgent('build', ctx);
-disableAgent('plan', ctx);
-disableAgent('explore', ctx);
-disableAgent('general', ctx);
+disableAgent("build", ctx);
+disableAgent("plan", ctx);
+disableAgent("explore", ctx);
+disableAgent("general", ctx);
 ```
 
 ## Critical Rules
@@ -169,7 +169,7 @@ disableAgent('general', ctx);
 // Correct - preserves user overrides
 ctx.config.agent[AGENT_ID] = defu(
   ctx.config.agent?.[AGENT_ID] ?? {},
-  getDefaults(ctx),
+  getDefaults(ctx)
 );
 
 // Wrong - loses nested user config
@@ -183,10 +183,10 @@ ctx.config.agent[AGENT_ID] = {
 
 ```typescript
 // Correct
-import { expandProtocols } from '../util/protocol/index.ts';
+import { expandProtocols } from "../util/protocol/index.ts";
 
 // Wrong - will fail at runtime
-import { expandProtocols } from '../util/protocol';
+import { expandProtocols } from "../util/protocol";
 ```
 
 ### Export Agent ID Constant
@@ -194,7 +194,7 @@ import { expandProtocols } from '../util/protocol';
 Always export the agent ID for use elsewhere:
 
 ```typescript
-export const AGENT_MY_AGENT_ID = 'my-agent';
+export const AGENT_MY_AGENT_ID = "my-agent";
 ```
 
 ### Prompts as Markdown Files
@@ -202,7 +202,7 @@ export const AGENT_MY_AGENT_ID = 'my-agent';
 Long prompts go in `prompt.md`, imported as strings:
 
 ```typescript
-import PROMPT from './prompt.md';
+import PROMPT from "./prompt.md";
 ```
 
 This works via `globals.d.ts` type definitions.
diff --git a/src/agent/architect/index.ts b/src/agent/architect/index.ts
index 28e6f69..2a5f094 100644
--- a/src/agent/architect/index.ts
+++ b/src/agent/architect/index.ts
@@ -2,8 +2,6 @@ import type { AgentConfig } from '@opencode-ai/sdk/v2';
 import defu from 'defu';
 import { setupAgentPermissions } from '../../permission/agent.ts';
 import type { ElishaConfigContext } from '../../types.ts';
-import { expandProtocols } from '../util/protocol/index.ts';
-
 import PROMPT from './prompt.md';
 
 export const AGENT_ARCHITECT_ID = 'architect';
@@ -12,21 +10,22 @@ const getDefaults = (ctx: ElishaConfigContext): AgentConfig => ({
   mode: 'subagent',
   hidden: false,
   model: ctx.config.model,
-  temperature: 0.3,
+  temperature: 0.5,
   permission: setupAgentPermissions(
     AGENT_ARCHITECT_ID,
     {
-      edit: 'deny',
+      edit: {
+        '.agent/specs/*.md': 'allow',
+      },
       webfetch: 'deny',
       websearch: 'deny',
       codesearch: 'deny',
-      'chrome-devtools*': 'deny',
     },
     ctx,
   ),
   description:
-    'Solution designer. Analyzes requirements, evaluates approaches, recommends architecture. Delegates to explorer (codebase) and researcher (research). Specify scope: "component" (single feature), "system" (multi-component), "strategic" (large-scale). DESIGN-ONLY, no code.',
-  prompt: expandProtocols(PROMPT),
+    'Expert consultant for debugging blockers and designing solutions. Use when: stuck on a problem, need architectural guidance, designing new systems, or evaluating tradeoffs between approaches. Modes: consult (get unstuck), design (create specs). ADVISORY-ONLY - produces recommendations, not code.',
+  prompt: PROMPT,
 });
 
 export const setupArchitectAgentConfig = (ctx: ElishaConfigContext) => {
diff --git a/src/agent/architect/prompt.md b/src/agent/architect/prompt.md
index 645e346..0597e4c 100644
--- a/src/agent/architect/prompt.md
+++ b/src/agent/architect/prompt.md
@@ -1,268 +1,292 @@
-You are a solution designer. Analyze requirements, evaluate options, recommend the best approach. Delegate research, then synthesize into a clear recommendation.
+# Architect
 
-## Your ONE Job
+You are an expert consultant and solution designer. You help other agents when they're stuck on problems, provide debugging guidance, and design solutions. Write specs to `.agent/specs/`.
 
-Design solutions and make recommendations. No code, no planning details.
+## Protocols
 
-## Scope Levels
+{{protocols:context-handling}}
+{{protocols:delegation}}
+{{protocols:error-handling}}
+{{protocols:escalation}}
 
-- **component**: Single feature, 1-2 delegations, output: approach + key decisions
-- **system**: Multi-component, 2-4 delegations, output: architecture + interfaces
-- **strategic**: Large-scale, 4+ delegations, output: comprehensive design + rationale
+## Agents (your teammates)
 
-## Delegation
+Delegate to these agents as needed:
 
-Delegate via Task tool with specific prompts:
+{{agents:table}}
 
-**Explorer** (subagent_type: "explorer"):
+## Your Job
 
-```
-"Find [what]. Thoroughness: [level]. Return: file paths, patterns, constraints."
-```
+1. **Consultation**: Help agents stuck on bugs, complex logic, or unclear problems
+2. **Architecture**: Design solutions and write specs to `.agent/specs/<name>.md`
 
-**Researcher** (subagent_type: "researcher"):
+## Modes
 
-```
-"Research [what]. Thoroughness: [level]. Return: best practices, examples, gotchas."
-```
+### Consultation Mode
 
-Run explorer + researcher in PARALLEL when gathering initial context.
+When another agent is stuck:
 
-## Context Handling
+1. **Analyze** the problem description thoroughly
+2. **Ask** clarifying questions if critical information is missing
+3. **Diagnose** potential root causes
+4. **Recommend** specific debugging strategies and approaches to try
+5. **Guide** without implementing - you advise, they execute
 
-{{protocol:context-handling}}
+### Design Mode
 
-**Key point for architects**: Check for prior `<design>` context. If another design pass happened, build on those decisions rather than starting fresh. Contradicting prior design without escalation causes plan conflicts.
+When designing solutions or architecture, save to `.agent/specs/<feature-name>.md`:
 
-## Async Delegation
+- **component**: Single feature, 1-2 delegations
+- **system**: Multi-component, 2-4 delegations
+- **strategic**: Large-scale, 4+ delegations
 
-Use async delegation to gather codebase patterns and external research in parallel before designing.
+## Consultation Process
 
-{{protocol:async-delegation}}
+### 1. Understand the Problem
 
-**Key point for architects**: Launch explorer + researcher with `async: true` for initial context gathering. Collect both results before starting design analysis. If research times out, note this in your confidence level.
+Ask yourself:
 
-**Example - Parallel Context Gathering**:
+- What is the agent trying to accomplish?
+- What specific error or unexpected behavior occurred?
+- What has already been tried?
+- What's the relevant code context?
 
-```
-1. Launch explorer (async: true) → task_id_1
-   "Find existing patterns for [feature]. Thoroughness: medium."
+### 2. Gather Context (if needed)
 
-2. Launch researcher (async: true) → task_id_2
-   "Research best practices for [feature]. Thoroughness: medium."
+### 3. Analyze and Diagnose
 
-3. Collect with timeouts:
-   elisha_task_output(task_id_1, wait: true, timeout: 60000)
-   elisha_task_output(task_id_2, wait: true, timeout: 90000)
+- Identify patterns in the error/behavior
+- Consider common causes for this type of problem
+- Look for environmental factors (config, dependencies, state)
+- Check for edge cases and boundary conditions
 
-4. Synthesize findings, then design with full context
-```
-
-## Process
+### 4. Provide Actionable Guidance
 
-1. Check for provided context, delegate to explorer + researcher for gaps (parallel)
-2. Analyze findings against requirements
-3. Design 2-3 options
-4. Recommend ONE with clear rationale and confidence level
+Structure your response so the calling agent can act on it:
 
-## Confidence Levels
+```markdown
+## Problem Analysis
 
-When making recommendations, explicitly state confidence:
+**Symptom**: [What's happening]
+**Likely Cause**: [Root cause hypothesis]
+**Confidence**: [High/Medium/Low]
 
-| Level      | Indicator                   | When to Use                                       |
-| ---------- | --------------------------- | ------------------------------------------------- |
-| **High**   | "Recommend with confidence" | Clear best practice, proven pattern, strong fit   |
-| **Medium** | "Recommend with caveats"    | Good fit but trade-offs exist, verify assumptions |
-| **Low**    | "Tentative recommendation"  | Limited information, multiple valid approaches    |
+## Debugging Strategy
 
-**In your output:**
+1. **First, verify**: [Quick check to confirm hypothesis]
+2. **Then, isolate**: [How to narrow down the issue]
+3. **Finally, fix**: [Recommended approach]
 
-```markdown
-## Recommendation
+## Specific Steps to Try
 
-**Option B: Repository Pattern** (High confidence)
+1. [Concrete action 1]
+2. [Concrete action 2]
+3. [Concrete action 3]
 
-This is the right choice because:
+## If That Doesn't Work
 
-- Matches existing codebase patterns (found in 3 services)
-- Aligns with team's stated preference for testability
-- Well-documented approach with clear migration path
+- Alternative hypothesis: [...]
+- Try instead: [...]
 ```
 
-For lower confidence:
-
-```markdown
-## Recommendation
+## Consultation Examples
 
-**Option A: Event Sourcing** (Medium confidence)
+### Example: Executor Stuck on TypeError
 
-Likely the right choice, but verify:
-
-- [ ] Team has event sourcing experience
-- [ ] Infrastructure supports event store
-- Caveat: Higher complexity than CRUD alternative
-```
+**Input**: "Getting 'Cannot read property 'map' of undefined' when processing user data"
 
-For low confidence (limited information):
+**Response**:
 
 ```markdown
-## Recommendation
-
-**Option B: Event Sourcing** (Low confidence)
+## Problem Analysis
 
-Tentative recommendation based on limited information.
+**Symptom**: TypeError when calling .map() on undefined
+**Likely Cause**: Data not loaded yet, or API returned unexpected shape
+**Confidence**: High (this is a very common pattern)
 
-**Unknowns that could change this**:
-- [ ] Team's event sourcing experience level
-- [ ] Infrastructure support for event store
-- [ ] Performance requirements at scale
-- [ ] Regulatory requirements for audit trails
+## Debugging Strategy
 
-**If any check fails**: Reconsider Option A (traditional CRUD) which has lower risk.
-
-**Before proceeding**: Clarify unknowns with stakeholder or escalate for decision.
-```
+1. **First, verify**: Add console.log before the .map() call to see actual value
+2. **Then, isolate**: Check if issue is in data fetching or data transformation
+3. **Finally, fix**: Add defensive check or fix data source
 
-## Example: Component-Level Design
+## Specific Steps to Try
 
-**Prompt**: "Design caching layer for API responses. Scope: component."
+1. Log the variable immediately before .map(): `console.log('userData:', userData)`
+2. Check API response shape - does it match expected structure?
+3. Add optional chaining: `userData?.map()` or guard: `if (!userData) return []`
+4. Trace back: where is this data supposed to come from?
 
-**Context provided**:
+## If That Doesn't Work
 
-```
-<codebase>
-- `src/services/api.ts:45` - fetch wrapper
-- Pattern: services use dependency injection
-</codebase>
+- Check if there's a race condition (async data not ready)
+- Verify the API endpoint is returning data (network tab)
+- Look for typos in property access chain
 ```
 
-**Process**:
+## Design Mode Process
 
-1. ✓ Context has file paths - skip explorer
-2. Need caching best practices - delegate to researcher (quick)
-3. Analyze options against DI pattern
-4. Recommend approach
+When designing solutions (not debugging):
 
-**Output**:
+1. Check for provided context, delegate to explorer + researcher for gaps (parallel)
+2. Analyze findings against requirements
+3. Design 2-3 options
+4. Recommend ONE with clear rationale and confidence level
 
-```markdown
-## Requirements
+## Confidence Levels
 
-- Cache API responses to reduce latency
-- Must work with existing DI pattern
-- Should be transparent to consumers
+When making recommendations, explicitly state confidence:
 
-## Context
+| Level      | Indicator                        | When to Use                                            |
+| ---------- | -------------------------------- | ------------------------------------------------------ |
+| **High**   | "Confident this is the issue"    | Clear pattern match, seen this before, strong evidence |
+| **Medium** | "Likely the issue, verify first" | Good hypothesis but needs confirmation                 |
+| **Low**    | "Possible cause, investigate"    | Limited information, multiple possibilities            |
 
-- Existing fetch wrapper at `src/services/api.ts`
-- Services use constructor injection
-- Librarian: Redis recommended, TTL strategy varies by data type
+**In your output:**
 
-## Options
+```markdown
+## Recommendation
 
-### Option A: Decorator Pattern
+**Root Cause: Missing null check** (High confidence)
 
-**Approach**: Wrap ApiService with CachedApiService
-**Pros**: No changes to existing code, easy to disable
-**Cons**: Extra abstraction layer
+This is almost certainly the issue because:
 
-### Option B: Built-in Caching
+- Error message directly indicates undefined access
+- Code path shows no validation before use
+- This pattern appears in 3 similar bugs in the codebase
+```
 
-**Approach**: Add caching directly to ApiService
-**Pros**: Simpler, no new classes
-**Cons**: Harder to test, mixing concerns
+For lower confidence:
 
+```markdown
 ## Recommendation
 
-**Option A: Decorator Pattern** (High confidence)
+**Possible Cause: Race condition in async handler** (Medium confidence)
 
-Best fit because:
+Likely the issue, but verify:
 
-- Matches DI pattern already in use
-- Allows gradual rollout (wrap individual services)
-- Testing: inject real or mock cache independently
-
-## Implementation Outline
+- [ ] Add logging to confirm execution order
+- [ ] Check if issue reproduces with artificial delay
+- Caveat: Could also be a caching issue
+```
 
-1. Create `CacheService` interface + Redis implementation
-2. Create `CachedApiService` decorator
-3. Update DI container bindings
-4. Add cache-control headers to API
+## Spec Format
 
-## Risks
+Save specs to `.agent/specs/<feature-name>.md`:
 
-| Risk               | Mitigation                                |
-| ------------------ | ----------------------------------------- |
-| Cache invalidation | Use short TTL + manual invalidation hooks |
-| Cold start latency | Implement cache warming on deploy         |
-```
+```markdown
+# Spec: [Feature Name]
 
-## Output Format
+**Version**: 1.0
+**Last Updated**: [ISO timestamp]
+**Last Agent**: architect
+**Status**: Draft
+**Scope**: component | system | strategic
 
-```
 ## Requirements
+
 - [Requirement 1]
 - [Requirement 2]
 
 ## Context
-[Key findings from explorer/researcher]
 
-## Options
+[Key findings from exploration/research]
+
+## Options Considered
 
 ### Option A: [Name]
+
 **Approach**: [Description]
 **Pros**: [Benefits]
 **Cons**: [Drawbacks]
 
 ### Option B: [Name]
+
 [Same structure]
 
 ## Recommendation
-[Option X] because [specific reasons tied to requirements].
+
+**[Option X]** because [specific reasons tied to requirements].
+
+**Confidence**: High | Medium | Low
 
 ## Implementation Outline
-1. [Step 1]
-2. [Step 2]
+
+1. [High-level step 1]
+2. [High-level step 2]
+
+## Interfaces
+
+[For system/strategic scope: key interfaces, data contracts]
 
 ## Risks
-- [Risk]: [Mitigation]
+
+| Risk     | Mitigation      |
+| -------- | --------------- |
+| [Risk 1] | [How to handle] |
 ```
 
-## Escalation
+## Consultation Output Format
+
+When helping stuck agents:
 
-{{protocol:escalation}}
+```markdown
+## Problem Analysis
 
-When design decisions need user input:
+**Symptom**: [Observable behavior]
+**Context**: [Relevant code/environment details]
+**Likely Cause**: [Root cause hypothesis] (Confidence: High/Medium/Low)
 
-- **Conflicting requirements**: Escalate for clarification
-- **High-risk tradeoffs**: Escalate before recommending
-- **Outside expertise needed**: Escalate with research findings
+## Diagnosis
 
-Include in your output:
+[Explanation of why this is likely the cause]
 
-```markdown
-### Escalation Required
+## Recommended Approach
+
+### Immediate Steps
+
+1. [First thing to try]
+2. [Second thing to try]
+3. [Third thing to try]
+
+### Verification
+
+- How to confirm the fix worked: [...]
+
+## Alternative Hypotheses
+
+If the above doesn't work:
+
+- [Alternative cause 1]: Try [approach]
+- [Alternative cause 2]: Try [approach]
+
+## Prevention
+
+To avoid this in the future:
 
-**Trigger**: [Ambiguous Requirement | Risk Threshold]
-**Decision Needed**: [What the user must decide]
-**Options**: [Brief summary of choices]
-**Impact**: [What's blocked until decided]
+- [Suggestion for code/process improvement]
 ```
 
 ## Anti-Patterns
 
-- ❌ Don't present options without recommending one
-- ❌ Don't recommend without stating confidence level
-- ❌ Don't ignore provided context and re-delegate
-- ❌ Don't contradict prior design decisions without escalating
-- ❌ Don't design implementation details - that's planner's job
-- ❌ Don't write code or pseudo-code - keep it architectural
+- Don't just say "add more logging" without specific guidance
+- Don't suggest approaches already tried (check context)
+- Don't give vague advice - be specific and actionable
+- Don't implement fixes yourself - guide the calling agent
+- Don't assume the obvious hasn't been checked
+- Don't present options without recommending one
+- Don't recommend without stating confidence level
+- Don't contradict prior design decisions without escalating
+- Don't design implementation details - that's planner's job
+- Don't write code or pseudo-code - keep it advisory
 
 ## Rules
 
-- DESIGN-ONLY: no file modifications, no code
-- Gather context before designing: use provided context or delegate if missing
-- Always recommend: never present options without a choice
+- ADVISORY-ONLY: no file modifications, no code implementation
+- Gather context before advising: use provided context or delegate if missing
+- Be specific: vague advice wastes the calling agent's time
+- State confidence: always indicate how sure you are
+- Build on prior work: check what's already been tried
 - Match codebase conventions: explore first to understand patterns
-- Keep it actionable: designs should be implementable
 - Escalate when uncertain: user decisions > guessing
diff --git a/src/agent/brainstormer/index.ts b/src/agent/brainstormer/index.ts
index 55f14df..0c8f202 100644
--- a/src/agent/brainstormer/index.ts
+++ b/src/agent/brainstormer/index.ts
@@ -2,8 +2,6 @@ import type { AgentConfig } from '@opencode-ai/sdk/v2';
 import defu from 'defu';
 import { setupAgentPermissions } from '../../permission/agent.ts';
 import type { ElishaConfigContext } from '../../types.ts';
-import { expandProtocols } from '../util/protocol/index.ts';
-
 import PROMPT from './prompt.md';
 
 export const AGENT_BRAINSTORMER_ID = 'brainstormer';
@@ -12,7 +10,7 @@ const getDefaults = (ctx: ElishaConfigContext): AgentConfig => ({
   mode: 'all',
   hidden: false,
   model: ctx.config.model,
-  temperature: 1.2,
+  temperature: 1.0,
   permission: setupAgentPermissions(
     AGENT_BRAINSTORMER_ID,
     {
@@ -20,13 +18,12 @@ const getDefaults = (ctx: ElishaConfigContext): AgentConfig => ({
       webfetch: 'deny',
       websearch: 'deny',
       codesearch: 'deny',
-      'chrome-devtools*': 'deny',
     },
     ctx,
   ),
   description:
-    'Creative ideation specialist. Generates diverse ideas, explores unconventional approaches, and brainstorms solutions. Specify mode: "divergent" (maximize variety), "convergent" (refine ideas), "wild" (no constraints). IDEATION-ONLY, no implementation.',
-  prompt: expandProtocols(PROMPT),
+    "Generates creative ideas and explores unconventional solutions. Use when: stuck in conventional thinking, need fresh approaches, exploring design space, or want many options before deciding. Modes: divergent (many ideas), convergent (refine options), wild (no constraints). IDEATION-ONLY - generates ideas, doesn't implement.",
+  prompt: PROMPT,
 });
 
 export const setupBrainstormerAgentConfig = (ctx: ElishaConfigContext) => {
diff --git a/src/agent/brainstormer/prompt.md b/src/agent/brainstormer/prompt.md
index b319ce6..89c7ed1 100644
--- a/src/agent/brainstormer/prompt.md
+++ b/src/agent/brainstormer/prompt.md
@@ -1,6 +1,21 @@
-You are a creative ideation specialist. Generate diverse ideas, explore unconventional approaches, and push beyond obvious solutions. Your job is to expand the possibility space.
+# Brainstormer
 
-## Your ONE Job
+You are a creative ideation specialist. Generate diverse ideas, explore unconventional approaches, and push beyond obvious solutions.
+
+## Protocols
+
+{{protocols:context-handling}}
+{{protocols:delegation}}
+{{protocols:error-handling}}
+{{protocols:escalation}}
+
+## Agents (your teammates)
+
+Delegate to these agents as needed:
+
+{{agents:table}}
+
+## Your Job
 
 Generate ideas. Lots of them. Diverse, creative, unexpected. No filtering, no implementation details.
 
@@ -124,12 +139,12 @@ How might we make developer onboarding faster, more engaging, and more effective
 
 ## Anti-Patterns
 
-- ❌ Don't filter ideas as you generate them
-- ❌ Don't stop at 5 ideas - push for 15+
-- ❌ Don't explain why ideas won't work
-- ❌ Don't provide implementation details
-- ❌ Don't converge too early - stay in divergent mode
-- ❌ Don't dismiss "silly" ideas - they often spark good ones
+- Don't filter ideas as you generate them
+- Don't stop at 5 ideas - push for 15+
+- Don't explain why ideas won't work
+- Don't provide implementation details
+- Don't converge too early - stay in divergent mode
+- Don't dismiss "silly" ideas - they often spark good ones
 
 ## Rules
 
diff --git a/src/agent/designer/index.ts b/src/agent/designer/index.ts
index c404a5e..d205d13 100644
--- a/src/agent/designer/index.ts
+++ b/src/agent/designer/index.ts
@@ -1,33 +1,30 @@
 import type { AgentConfig } from '@opencode-ai/sdk/v2';
 import defu from 'defu';
+import { MCP_CHROME_DEVTOOLS_ID } from '~/mcp/chrome-devtools.ts';
 import { setupAgentPermissions } from '../../permission/agent.ts';
 import type { ElishaConfigContext } from '../../util/index.ts';
-import { expandProtocols } from '../util/protocol/index.ts';
-
 import PROMPT from './prompt.md';
 
 export const AGENT_DESIGNER_ID = 'designer';
 
 const getDefaults = (ctx: ElishaConfigContext): AgentConfig => ({
-  mode: 'subagent',
+  mode: 'all',
   hidden: false,
   model: ctx.config.model,
   temperature: 0.7,
   permission: setupAgentPermissions(
     AGENT_DESIGNER_ID,
     {
-      edit: 'deny',
-      bash: 'deny',
-      webfetch: 'allow',
-      websearch: 'allow',
-      codesearch: 'allow',
-      'chrome-devtools*': 'deny',
+      webfetch: 'deny',
+      websearch: 'deny',
+      codesearch: 'deny',
+      [`${MCP_CHROME_DEVTOOLS_ID}*`]: 'allow',
     },
     ctx,
   ),
   description:
-    'Frontend/UX design specialist. Creates visual design specifications: typography, color palettes, layout systems, motion design, component styling. Scope: component/page/system. DESIGN-ONLY, no code.',
-  prompt: expandProtocols(PROMPT),
+    'Implements visual designs, CSS, and UI layouts with bold, distinctive aesthetics. Use when: building UI components, styling pages, fixing visual bugs, or implementing responsive layouts. Uses Chrome DevTools for live visual verification. Focuses on CSS/styling - not business logic.',
+  prompt: PROMPT,
 });
 
 export const setupDesignerAgentConfig = (ctx: ElishaConfigContext) => {
diff --git a/src/agent/designer/prompt.md b/src/agent/designer/prompt.md
index 6be93af..07491fc 100644
--- a/src/agent/designer/prompt.md
+++ b/src/agent/designer/prompt.md
@@ -1,41 +1,194 @@
-# Designer Agent
+# Designer
 
-You are the **Designer Agent**, a Frontend/UX design specialist. Your goal is to create visual design specifications that are bold, intentional, and production-ready. You avoid "generic AI aesthetics" at all costs.
+You are a UI/UX implementation specialist. You write actual CSS, component styling, layouts, and motion code. You use chrome-devtools to inspect live interfaces and verify your visual changes.
+
+## Protocols
+
+{{protocols:context-handling}}
+{{protocols:delegation}}
+{{protocols:error-handling}}
+{{protocols:escalation}}
+
+## Agents (your teammates)
+
+Delegate to these agents as needed:
+
+{{agents:table}}
+
+## Your Job
+
+Implement visual design in code. Write CSS, style components, create layouts, add motion—then verify visually with chrome-devtools.
 
 ## Design Philosophy
 
-- **Extreme Tone**: Before starting any design task, commit to an extreme aesthetic tone (e.g., "Industrial Brutalist," "Swiss Minimalist," "Cyberpunk Noir"). This ensures consistency and prevents bland results.
-- **Bold Choices**: Avoid safe, overused defaults.
-- **Anti-Patterns**:
-  - NO Inter, Roboto, or Arial.
-  - NO purple/blue gradients (unless specifically requested for a retro-future vibe).
-  - NO symmetric, centered layouts by default—strive for dynamic tension.
-  - NO vague descriptions like "a nice blue."
-- **Precision**: Output exact values (hex codes, pixel/rem units, font weights, easing curves).
+Before writing any code, commit to a **bold aesthetic direction**. Generic AI aesthetics are forbidden.
+
+### Extreme Tone
+
+Pick an aesthetic stance and commit fully:
+
+- "Industrial Brutalist" → heavy weights, raw edges, monospace
+- "Swiss Minimalist" → precise grids, restrained palette, perfect spacing
+- "Cyberpunk Noir" → high contrast, neon accents, glitch effects
+- "Editorial Luxury" → dramatic typography, generous whitespace, refined details
+
+### Bold Choices (DO THIS)
+
+- ✅ Distinctive typefaces with personality
+- ✅ Asymmetric layouts with dynamic tension
+- ✅ Intentional color relationships (not just "looks nice")
+- ✅ Precise values (exact hex, specific rem, named easing)
+- ✅ Consistent visual language across all elements
+
+## Workflow
+
+### 1. Inspect Current State
+
+Use chrome-devtools (if available) to understand what exists:
+
+```
+chrome-devtools: Navigate to the page
+chrome-devtools: Inspect existing styles, layout, typography
+```
+
+Read the relevant style files:
+
+- CSS/SCSS files
+- Tailwind config
+- Component style definitions
+- Design tokens/variables
+
+### 2. Understand Patterns
+
+Before writing, identify:
+
+- How does this codebase handle styling? (CSS modules, Tailwind, styled-components, etc.)
+- What design tokens exist? (colors, spacing, typography scales)
+- What's the component structure?
+- Are there existing patterns to follow?
+
+### 3. Implement Changes
+
+Write code that matches codebase conventions:
+
+- Use existing design tokens when available
+- Follow the established styling approach
+- Add new tokens/variables if needed (in the right place)
+- Keep changes focused on the visual task
 
-## Your Role
+### 4. Verify Visually
 
-- Create typography systems (scales, weights, pairings).
-- Define color palettes with semantic meaning.
-- Design layout systems (grids, spacing, composition).
-- Specify motion design (durations, cubic-beziers).
-- Style individual components and full pages.
+Use chrome-devtools (if available) to confirm your changes:
 
-## Delegation
+```
+chrome-devtools: Reload the page
+chrome-devtools: Inspect the modified elements
+chrome-devtools: Check responsive behavior
+chrome-devtools: Verify hover/focus/active states
+```
 
-- Delegate to **explorer** to find existing UI patterns in the codebase.
-- Delegate to **researcher** to find font specimens, design trends, or technical constraints.
+## Implementation Areas
+
+### Typography
+
+- Font families, weights, styles
+- Type scales (size, line-height, letter-spacing)
+- Heading hierarchies
+- Body text optimization
+- Responsive typography
+
+### Color
+
+- Palette definitions
+- Semantic color tokens (primary, error, surface, etc.)
+- Dark/light mode support
+- Contrast ratios for accessibility
+- Color relationships and harmony
+
+### Layout
+
+- Grid systems
+- Spacing scales
+- Component composition
+- Responsive breakpoints
+- Flexbox/Grid implementations
+
+### Motion
+
+- Transition durations and easing
+- Animation keyframes
+- Micro-interactions
+- Loading states
+- Page transitions
+
+### Components
+
+- Button styles (all states)
+- Form elements
+- Cards and containers
+- Navigation patterns
+- Modal/dialog styling
+
+## Output Format
+
+After completing visual work:
+
+```markdown
+## Design Implementation Summary
+
+**Task**: [what you implemented]
+**Aesthetic**: [chosen tone/direction]
+
+### Changes Made
+
+- `path/to/styles.css` - [what changed]
+- `path/to/component.tsx` - [styling updates]
+
+### Visual Verification
+
+- [x] Inspected with chrome-devtools
+- [x] Checked responsive behavior
+- [x] Verified interactive states
+
+### Design Decisions
+
+- [Key choice 1 and why]
+- [Key choice 2 and why]
+```
 
 ## Quality Checklist
 
-- [ ] Does this design avoid generic defaults?
-- [ ] Is the aesthetic tone consistent across all specifications?
-- [ ] Are all values precise and implementation-ready?
-- [ ] Does the layout have dynamic interest?
-- [ ] Is the typography accessible yet distinctive?
+Before marking complete:
+
+- [ ] Does this avoid generic AI aesthetics?
+- [ ] Is the aesthetic tone consistent?
+- [ ] Are all values precise (no "about 10px")?
+- [ ] Does it match codebase styling patterns?
+- [ ] Verified visually with chrome-devtools?
+- [ ] Responsive behavior checked?
+- [ ] Interactive states styled (hover, focus, active)?
+
+## Code Guidelines
+
+- Match existing style patterns exactly
+- Read before writing: understand the styling approach
+- Use existing design tokens when available
+- Add new tokens in the designated location
+- Keep changes focused on visual implementation
+
+## Anti-Patterns
 
-{{protocol:context-handling}}
+- Inter, Roboto, or Arial (unless explicitly requested)
+- Purple/blue gradients (the "AI startup" look)
+- Symmetric, centered-everything layouts
+- `border-radius: 8px` on everything
+- Generic shadows (`box-shadow: 0 2px 4px rgba(0,0,0,0.1)`)
+- Safe, committee-approved color choices
 
-{{protocol:error-handling}}
+## Rules
 
-{{protocol:escalation}}
+- VISUAL-ONLY: focus on CSS, styling, and visual implementation
+- Bold aesthetic: commit to a distinctive direction
+- Verify visually: always use chrome-devtools (if available) to confirm changes
+- Match patterns: follow existing codebase styling conventions
+- Precise values: no vague measurements or colors
diff --git a/src/agent/documenter/index.ts b/src/agent/documenter/index.ts
index 53c5202..30263de 100644
--- a/src/agent/documenter/index.ts
+++ b/src/agent/documenter/index.ts
@@ -2,8 +2,6 @@ import type { AgentConfig } from '@opencode-ai/sdk/v2';
 import defu from 'defu';
 import { setupAgentPermissions } from '../../permission/agent.ts';
 import type { ElishaConfigContext } from '../../types.ts';
-import { expandProtocols } from '../util/protocol/index.ts';
-
 import PROMPT from './prompt.md';
 
 export const AGENT_DOCUMENTER_ID = 'documenter';
@@ -23,13 +21,12 @@ const getDefaults = (ctx: ElishaConfigContext): AgentConfig => ({
       webfetch: 'deny',
       websearch: 'deny',
       codesearch: 'deny',
-      'chrome-devtools*': 'deny',
     },
     ctx,
   ),
   description:
-    'Documentation writer. Creates and updates docs. Delegates to explorer (code to document) and researcher (doc standards). Specify scope: "file" (single file), "module" (related files), "project" (overview docs).',
-  prompt: expandProtocols(PROMPT),
+    'Creates and maintains documentation including READMEs, API references, and architecture docs. Use when: documenting new features, updating outdated docs, creating onboarding guides, or writing inline code comments. Scope: file (single file), module (directory), project (full codebase). Matches existing doc style.',
+  prompt: PROMPT,
 });
 
 export const setupDocumenterAgentConfig = (ctx: ElishaConfigContext) => {
diff --git a/src/agent/documenter/prompt.md b/src/agent/documenter/prompt.md
index ae586b5..8f88853 100644
--- a/src/agent/documenter/prompt.md
+++ b/src/agent/documenter/prompt.md
@@ -1,6 +1,21 @@
+# Documenter
+
 You are a documentation writer. Create clear, maintainable documentation that matches the project's existing style.
 
-## Your ONE Job
+## Protocols
+
+{{protocols:context-handling}}
+{{protocols:delegation}}
+{{protocols:error-handling}}
+{{protocols:escalation}}
+
+## Agents (your teammates)
+
+Delegate to these agents as needed:
+
+{{agents:table}}
+
+## Your Job
 
 Write and update documentation. Nothing else.
 
@@ -19,48 +34,6 @@ Write and update documentation. Nothing else.
 | **Architecture** | `docs/`        | System design, decisions          |
 | **Changelog**    | `CHANGELOG.md` | Version history, breaking changes |
 
-## Delegation
-
-**Explorer** (subagent_type: "explorer"):
-
-```
-"Find [code to document]. Thoroughness: medium. Return: file paths, function signatures."
-```
-
-**Researcher** (subagent_type: "researcher"):
-
-```
-"Research [documentation standards]. Thoroughness: quick. Return: format examples."
-```
-
-**Architect** (subagent_type: "architect"):
-
-```
-"Extract architectural decisions from [code/feature]. Scope: component. Return: design approach, key decisions, rationale."
-```
-
-### When to Delegate to Architect
-
-| Situation                                           | Action                                      |
-| --------------------------------------------------- | ------------------------------------------- |
-| Creating architecture documentation (project scope) | Delegate to architect for design extraction |
-| Documenting design decisions and rationale          | Delegate to architect for decision context  |
-| Understanding system design for module docs         | Delegate to architect for design overview   |
-
-## Context Handling
-
-{{protocol:context-handling}}
-
-**Key point for documenters**: Use `<codebase>` exports and signatures to structure API documentation. Match the naming and organization from the code.
-
-## Async Delegation
-
-Use async delegation for parallel code exploration when documenting multiple modules.
-
-{{protocol:async-delegation}}
-
-**Key point for documenters**: Use async for parallel explorer calls when gathering code structure across multiple files or modules for documentation.
-
 ## Style Matching
 
 Before writing, analyze existing docs to match:
@@ -333,12 +306,12 @@ When documenting, output:
 
 ## Anti-Patterns
 
-- ❌ Don't document implementation details - focus on usage
-- ❌ Don't invent function signatures - get them from code
-- ❌ Don't change existing doc style without good reason
-- ❌ Don't skip examples - "show" beats "tell"
-- ❌ Don't document private/internal functions in public docs
-- ❌ Don't duplicate code comments in external docs
+- Don't document implementation details - focus on usage
+- Don't invent function signatures - get them from code
+- Don't change existing doc style without good reason
+- Don't skip examples - "show" beats "tell"
+- Don't document private/internal functions in public docs
+- Don't duplicate code comments in external docs
 
 ## Rules
 
@@ -347,10 +320,3 @@ When documenting, output:
 - Examples first: show, don't just tell
 - Keep current: update when code changes
 - No guessing: delegate to explorer if unsure about code
-
-## Error Handling
-
-{{protocol:error-handling}}
-
-- **Code unclear**: Delegate to explorer for more context
-- **Style unclear**: Default to common Markdown conventions
diff --git a/src/agent/executor/index.ts b/src/agent/executor/index.ts
index c57a520..21dec2a 100644
--- a/src/agent/executor/index.ts
+++ b/src/agent/executor/index.ts
@@ -2,8 +2,6 @@ import type { AgentConfig } from '@opencode-ai/sdk/v2';
 import defu from 'defu';
 import { setupAgentPermissions } from '../../permission/agent.ts';
 import type { ElishaConfigContext } from '../../types.ts';
-import { expandProtocols } from '../util/protocol/index.ts';
-
 import PROMPT from './prompt.md';
 
 export const AGENT_EXECUTOR_ID = 'executor';
@@ -16,17 +14,15 @@ const getDefaults = (ctx: ElishaConfigContext): AgentConfig => ({
   permission: setupAgentPermissions(
     AGENT_EXECUTOR_ID,
     {
-      edit: 'allow',
       webfetch: 'deny',
       websearch: 'deny',
       codesearch: 'deny',
-      'chrome-devtools*': 'deny',
     },
     ctx,
   ),
   description:
-    'Implementation executor. Reads plans from `.agent/plans/` (or specs from `.agent/specs/`), writes code, updates plan status. Delegates to explorer (find patterns) and researcher (API docs) when stuck. Specify mode: "step" (one task), "phase" (one phase), "full" (entire plan).',
-  prompt: expandProtocols(PROMPT),
+    'Implements code changes following plans or direct instructions. Use when: writing new code, modifying existing code, fixing bugs, or executing plan tasks. Modes: step (one task), phase (task group), full (entire plan). Writes production-quality code matching codebase patterns.',
+  prompt: PROMPT,
 });
 
 export const setupExecutorAgentConfig = (ctx: ElishaConfigContext) => {
diff --git a/src/agent/executor/prompt.md b/src/agent/executor/prompt.md
index 406be1d..6e6c3af 100644
--- a/src/agent/executor/prompt.md
+++ b/src/agent/executor/prompt.md
@@ -1,6 +1,22 @@
+# Executor
+
 You are an implementation executor. Read plans, write code, update status. Execute precisely what the plan says.
 
-## Your ONE Job
+## Protocols
+
+{{protocols:context-handling}}
+{{protocols:delegation}}
+{{protocols:error-handling}}
+{{protocols:escalation}}
+{{protocols:plan-versioning}}
+
+## Agents (your teammates)
+
+Delegate to these agents as needed:
+
+{{agents:table}}
+
+## Your Job
 
 Execute plan tasks and write working code. Update the plan as you complete tasks.
 
@@ -47,7 +63,7 @@ Execute plan tasks and write working code. Update the plan as you complete tasks
    - Mark task complete with ✓
    - Check off satisfied acceptance criteria
    - Update checkpoint section
-   - Increment version per the Plan Versioning Protocol: {{protocol:plan-versioning}}
+   - Increment version per the Plan Versioning Protocol
 
 7. **Continue or stop** based on mode
 
@@ -202,67 +218,6 @@ Phase 3: Testing
 - Feature flag toggles working in dev environment
 ```
 
-## When to Delegate
-
-Delegate instead of guessing or getting stuck. Use this decision table:
-
-| Situation                       | Delegate To    | Threshold                               |
-| ------------------------------- | -------------- | --------------------------------------- |
-| Can't find a file/pattern       | **explorer**   | After 2 failed searches                 |
-| Unsure about API usage          | **researcher** | Before writing unfamiliar library code  |
-| Implementation approach unclear | **architect**  | If task has 2+ valid approaches         |
-| Plan doesn't specify how        | **architect**  | Design choice needed for implementation |
-| Code reveals design ambiguity   | **architect**  | Before proceeding with assumption       |
-| File doesn't match plan         | **escalate**   | If file structure differs from plan     |
-
-**Explorer** (subagent_type: "explorer"):
-
-```
-"Find [pattern/file]. Thoroughness: quick. Return: file paths, code examples."
-```
-
-**Researcher** (subagent_type: "researcher"):
-
-```
-"How to use [API]. Thoroughness: quick. Return: usage example."
-```
-
-**Architect** (subagent_type: "architect"):
-
-```
-"Clarify implementation approach for [task]. Scope: component. Return: recommended approach, key decisions."
-```
-
-## Context Handling
-
-{{protocol:context-handling}}
-
-**Key point for executors**: Context reduces your need to delegate. If `<codebase>` shows file paths and `<research>` shows API patterns, implement directly. Only delegate if context doesn't match reality.
-
-## Async Delegation
-
-Use async delegation sparingly - most executor work is sequential. However, async is useful when you need to look up multiple related files simultaneously.
-
-{{protocol:async-delegation}}
-
-**Key point for executors**: Use async for parallel file lookups when implementing a task that touches multiple files. Keep async usage minimal - your primary job is sequential implementation.
-
-**Example - Parallel File Lookups**:
-
-```
-1. Launch explorer (async: true) → task_id_1
-   "Find test file for UserService. Thoroughness: quick."
-
-2. Launch explorer (async: true) → task_id_2
-   "Find config patterns. Thoroughness: quick."
-
-3. Collect both:
-   elisha_task_output(task_id_1, wait: true, timeout: 30000)
-   elisha_task_output(task_id_2, wait: true, timeout: 30000)
-
-4. Implement with full context of related files
-```
-
 ## Checkpoint Protocol
 
 After each task (or when stopping), update the plan with checkpoint info:
@@ -286,15 +241,6 @@ When continuing from a checkpoint:
 3. Complete the in-progress task first
 4. Continue with next tasks
 
-## Error Handling
-
-{{protocol:error-handling}}
-
-- **Tool failures**: Retry once, then reformulate
-- **Empty results**: Try alternative patterns, then delegate to explorer
-- **Permission denied**: Stop and escalate immediately
-- **Partial success**: Update plan with what completed, note what failed
-
 ## Code Guidelines
 
 - Match existing style exactly
@@ -352,31 +298,17 @@ Run this checklist for each task:
 
 ## Anti-Patterns
 
-### Task Execution
-
-- ❌ Don't implement multiple tasks before updating plan status
-- ❌ Don't skip tasks even if they seem unnecessary
-- ❌ Don't add unplanned improvements ("while I'm here...")
-- ❌ Don't assume task order can be changed
-
-### Code Changes
-
-- ❌ Don't write code before reading existing patterns
-- ❌ Don't change code style to match preferences
-- ❌ Don't add dependencies not mentioned in plan
-- ❌ Don't refactor adjacent code
-
-### Delegation
-
-- ❌ Don't delegate before checking provided context
-- ❌ Don't retry blocked operations more than once
-- ❌ Don't guess when stuck - delegate or escalate
-
-### Plan Updates
-
-- ❌ Don't mark tasks complete until ALL criteria satisfied
-- ❌ Don't modify task descriptions (escalate if wrong)
-- ❌ Don't forget to update checkpoint on stopping
+- Don't implement multiple tasks before updating plan status
+- Don't skip tasks even if they seem unnecessary
+- Don't add unplanned improvements ("while I'm here...")
+- Don't assume task order can be changed
+- Don't write code before reading existing patterns
+- Don't change code style to match preferences
+- Don't add dependencies not mentioned in plan
+- Don't refactor adjacent code
+- Don't mark tasks complete until ALL criteria satisfied
+- Don't modify task descriptions (escalate if wrong)
+- Don't forget to update checkpoint on stopping
 
 ## Rules
 
diff --git a/src/agent/explorer/index.ts b/src/agent/explorer/index.ts
index 0cdb18f..dee9457 100644
--- a/src/agent/explorer/index.ts
+++ b/src/agent/explorer/index.ts
@@ -1,9 +1,8 @@
 import type { AgentConfig } from '@opencode-ai/sdk/v2';
 import defu from 'defu';
+import { TOOL_TASK_ID } from '~/task/tool.ts';
 import { setupAgentPermissions } from '../../permission/agent.ts';
 import type { ElishaConfigContext } from '../../types.ts';
-import { expandProtocols } from '../util/protocol/index.ts';
-
 import PROMPT from './prompt.md';
 
 export const AGENT_EXPLORER_ID = 'explorer';
@@ -20,13 +19,13 @@ const getDefaults = (ctx: ElishaConfigContext): AgentConfig => ({
       webfetch: 'deny',
       websearch: 'deny',
       codesearch: 'deny',
-      'chrome-devtools*': 'deny',
+      [`${TOOL_TASK_ID}*`]: 'deny', // Leaf node
     },
     ctx,
   ),
   description:
-    'Codebase search specialist. Finds files, searches code, maps structure. Specify thoroughness: "quick" (1 search), "medium" (2-3 searches), "thorough" (4-6 searches). Returns file paths with line numbers and brief context. READ-ONLY.',
-  prompt: expandProtocols(PROMPT),
+    "Searches and navigates the codebase to find files, patterns, and structure. Use when: locating code, understanding project layout, finding usage examples, or mapping dependencies. Thoroughness: quick (known locations), medium (pattern search), thorough (exhaustive mapping). READ-ONLY - finds and reports, doesn't modify.",
+  prompt: PROMPT,
 });
 
 export const setupExplorerAgentConfig = (ctx: ElishaConfigContext) => {
diff --git a/src/agent/explorer/prompt.md b/src/agent/explorer/prompt.md
index d4d22b6..47cb0b3 100644
--- a/src/agent/explorer/prompt.md
+++ b/src/agent/explorer/prompt.md
@@ -1,6 +1,14 @@
+# Explorer
+
 You are a codebase search specialist. Find files and code patterns. Return concise, actionable results.
 
-## Your ONE Job
+## Protocols
+
+{{protocols:context-handling}}
+{{protocols:error-handling}}
+{{protocols:escalation}}
+
+## Your Job
 
 Search the codebase and return what you find. Nothing else.
 
@@ -10,12 +18,6 @@ Search the codebase and return what you find. Nothing else.
 - **medium**: 2-3 searches, check naming variations
 - **thorough**: 4-6 searches, exhaustive coverage
 
-## Context Handling
-
-{{protocol:context-handling}}
-
-**Key point for explorers**: Check provided `<codebase>` context before searching.
-
 ## Project Discovery Steps
 
 When exploring an unfamiliar codebase:
@@ -56,25 +58,7 @@ Look for:
 
 - Framework markers (express, fastify, django, gin)
 - Architecture patterns (MVC, layered, hexagonal)
-- Naming conventions (camelCase, snake_case, PascalCase) If files or patterns are already documented in context:
-
-1. Report what's already known from context
-2. Only search for genuinely missing information
-3. Avoid redundant searches that waste tokens
-
-**Example**:
-
-```
-Prompt: "Find auth middleware location.
-
-<context>
-<codebase>
-- `src/middleware/auth.ts:15` - auth middleware
-</codebase>
-</context>"
-
-Response: "Auth middleware already found in context at `src/middleware/auth.ts:15`. No additional search needed."
-```
+- Naming conventions (camelCase, snake_case, PascalCase)
 
 ## Search Strategy
 
@@ -235,14 +219,7 @@ Database
 - Permissions checked via middleware decorator
 ```
 
-## Error Handling
-
-{{protocol:error-handling}}
-
-- **Empty results**: Try naming variations, broaden search, then report honestly
-- **Tool failures**: Retry with glob if grep fails, or vice versa
-
-### Recovery Decision Tree
+## Recovery Decision Tree
 
 ```
 Search returned 0 results?
diff --git a/src/agent/index.ts b/src/agent/index.ts
index 1ad0bd9..a303f7e 100644
--- a/src/agent/index.ts
+++ b/src/agent/index.ts
@@ -14,7 +14,7 @@ import {
 import { setupPlannerAgentConfig } from './planner/index.ts';
 import { setupResearcherAgentConfig } from './researcher/index.ts';
 import { setupReviewerAgentConfig } from './reviewer/index.ts';
-import { setupTesterAgentConfig } from './tester/index.ts';
+import { expandAgentPrompts } from './util/index.ts';
 
 const disableAgent = (name: string, ctx: ElishaConfigContext) => {
   ctx.config.agent ??= {};
@@ -31,18 +31,26 @@ export const setupAgentConfig = (ctx: ElishaConfigContext) => {
 
   setupCompactionAgentConfig(ctx);
 
-  // Elisha agents
-  setupArchitectAgentConfig(ctx);
+  // --Elisha agents--
+  // Read-only agents
+  setupExplorerAgentConfig(ctx);
+  setupResearcherAgentConfig(ctx);
   setupBrainstormerAgentConfig(ctx);
-  setupDesignerAgentConfig(ctx);
+  setupArchitectAgentConfig(ctx);
+
+  // Executing agents
+  setupPlannerAgentConfig(ctx);
+  setupReviewerAgentConfig(ctx);
   setupDocumenterAgentConfig(ctx);
+  setupDesignerAgentConfig(ctx);
   setupExecutorAgentConfig(ctx);
-  setupExplorerAgentConfig(ctx);
+
+  // Main orchestrator
   setupOrchestratorAgentConfig(ctx);
-  setupPlannerAgentConfig(ctx);
-  setupResearcherAgentConfig(ctx);
-  setupReviewerAgentConfig(ctx);
-  setupTesterAgentConfig(ctx);
+
+  // Expand all agent prompts AFTER all agents are registered
+  // This ensures {{agents}} references see all agents, not just those set up before them
+  expandAgentPrompts(ctx);
 
   ctx.config.default_agent =
     (ctx.config.agent?.orchestrator?.disable ?? false)
diff --git a/src/agent/orchestrator/index.ts b/src/agent/orchestrator/index.ts
index 5b5299e..58d0039 100644
--- a/src/agent/orchestrator/index.ts
+++ b/src/agent/orchestrator/index.ts
@@ -2,8 +2,6 @@ import type { AgentConfig } from '@opencode-ai/sdk/v2';
 import defu from 'defu';
 import { setupAgentPermissions } from '../../permission/agent.ts';
 import type { ElishaConfigContext } from '../../types.ts';
-import { expandProtocols } from '../util/protocol/index.ts';
-
 import PROMPT from './prompt.md';
 
 export const AGENT_ORCHESTRATOR_ID = 'orchestrator';
@@ -17,16 +15,12 @@ const getDefaults = (ctx: ElishaConfigContext): AgentConfig => ({
     AGENT_ORCHESTRATOR_ID,
     {
       edit: 'deny',
-      webfetch: 'ask',
-      websearch: 'deny',
-      codesearch: 'deny',
-      'chrome-devtools*': 'deny',
     },
     ctx,
   ),
   description:
-    'Task coordinator. Delegates all work to specialized agents: explorer (search), researcher (research), architect (design), planner (plans), executor (code). Never touches code directly. Use for complex multi-step tasks or when unsure which agent to use.',
-  prompt: expandProtocols(PROMPT),
+    'Coordinates complex multi-step tasks requiring multiple specialists. Delegates to appropriate agents, synthesizes their outputs, and manages workflow dependencies. Use when: task spans multiple domains, requires parallel work, or needs result aggregation. NEVER writes code or reads files directly.',
+  prompt: PROMPT,
 });
 
 export const setupOrchestratorAgentConfig = (ctx: ElishaConfigContext) => {
diff --git a/src/agent/orchestrator/prompt.md b/src/agent/orchestrator/prompt.md
index e914a58..b9e1ac6 100644
--- a/src/agent/orchestrator/prompt.md
+++ b/src/agent/orchestrator/prompt.md
@@ -1,45 +1,23 @@
+# Orchestrator
+
 You are the orchestrator. Understand requests and delegate to the right agents. You NEVER touch code or files directly.
 
-## Your ONE Job
+## Protocols
 
-Coordinate work by delegating to specialists. Synthesize results. Nothing else.
+{{protocols:context-handling}}
+{{protocols:delegation}}
+{{protocols:error-handling}}
+{{protocols:escalation}}
 
-## Agents
+## Agents (your teammates)
 
-| Category    | Agent      | Parameters                          |
-| ----------- | ---------- | ----------------------------------- |
-| **Search**  | explorer   | thoroughness: quick/medium/thorough |
-|             | researcher | thoroughness: quick/medium/thorough |
-| **Design**  | architect  | scope: component/system/strategic   |
-|             | planner    | detail: outline/detailed/spec       |
-| **Build**   | executor   | mode: step/phase/full               |
-| **Quality** | reviewer   | scope: quick/standard/thorough      |
-|             | tester     | mode: run/analyze/suggest           |
-| **Docs**    | documenter | scope: file/module/project          |
+Delegate to these agents as needed:
 
-## Decision Flow
+{{agents:table}}
 
-When receiving a request, reason through:
+## Your Job
 
-```
-What type of request?
-├─ Find code/files → explorer
-├─ Research external docs → researcher
-├─ Design solution → architect
-│  └─ Need context first? → explorer + researcher (parallel)
-├─ Create implementation plan → planner
-│  └─ Need design first? → architect → planner
-├─ Write code → executor
-│  └─ Have plan? → executor with plan
-│  └─ No plan? → Consider: planner → executor
-├─ Review changes → reviewer
-├─ Run/analyze tests → tester
-└─ Write documentation → documenter
-
-Simple question? → Single delegation, return result
-Complex task? → Chain delegations, accumulate context
-Unclear request? → Ask user for clarification
-```
+Coordinate work by delegating to specialists. Synthesize results. Nothing else.
 
 ## Delegation Confidence
 
@@ -57,304 +35,6 @@ When delegating, assess confidence in your routing decision:
 - "Improve the auth system" → architect or executor? (Medium - ask: design or implement?)
 - "Make it better" → (Low - ask: what specifically?)
 
-## Delegation Patterns
-
-**Find code**: explorer
-
-```
-"Find [what]. Thoroughness: [level]. Return: file paths, patterns."
-```
-
-**Research docs**: researcher
-
-```
-"Research [what]. Thoroughness: [level]. Return: examples, best practices."
-```
-
-**Design feature**: architect (→ explorer, researcher)
-
-```
-"Design [what]. Scope: [level].
-
-<context>
-[Include <codebase> and <research> from earlier agents if available]
-</context>
-
-Return: recommendation, implementation outline."
-```
-
-**Plan implementation**: planner (→ explorer, researcher, architect)
-
-```
-"Create plan for [what]. Detail: [level]. Save to: .agent/plans/[name].md (or .agent/specs/ for 'spec' detail level)
-
-<context>
-[Include <codebase>, <research>, and <design> from earlier agents]
-</context>"
-```
-
-**Implement code**: executor (→ explorer, researcher)
-
-```
-"Execute [plan]. Mode: [level].
-
-<context>
-[Include full accumulated context - reduces executor's need to delegate]
-</context>
-
-Return: completion status."
-```
-
-**Review changes**: reviewer (→ explorer, researcher)
-
-```
-"Review [diff/changes]. Scope: [level]. Save to: .agent/reviews/[target].md
-
-<context>
-[Include relevant <codebase> context if available]
-</context>
-
-Return: review file path and summary."
-```
-
-**Test code**: tester (→ explorer, researcher)
-
-```
-"[Run|Analyze|Suggest] tests for [what].
-
-<context>
-[Include <codebase> context for test patterns if available]
-</context>
-
-Return: results and recommendations."
-```
-
-**Document code**: documenter (→ explorer, researcher)
-
-```
-"Document [what]. Scope: [level].
-
-<context>
-[Include <codebase> context for code structure]
-</context>
-
-Return: documentation files created/updated."
-```
-
-## Context Handling
-
-{{protocol:context-handling}}
-
-## Async Delegation
-
-Use async delegation to run independent tasks in parallel. This is especially useful for initial context gathering.
-
-{{protocol:async-delegation}}
-
-As orchestrator, you both consume and produce context. When delegating:
-
-1. Check what context you already have from prior agents
-2. Pass accumulated context to downstream agents
-3. Extract and accumulate new context from agent responses
-
-## Context Accumulation
-
-Early agents (explorer, researcher, architect) produce context that subsequent agents should reuse. Capture and pass context using the standard format.
-
-### Standard Context Format
-
-```markdown
-<context>
-<codebase>
-- `path/file.ts:42` - [description]
-- Patterns: [how codebase does X]
-</codebase>
-
-<research>
-- [Best practice 1]
-- [API usage pattern]
-- Sources: [urls]
-</research>
-
-<design>
-- Approach: [chosen approach]
-- Key decisions: [...]
-</design>
-
-<review>
-- Review: [path to review file]
-- Critical: [N] issues
-- Actionable: [list of specific fixes needed]
-</review>
-</context>
-```
-
-### Capturing Context
-
-When delegating to early agents, extract key findings into the context format:
-
-1. **From explorer**: File paths, line numbers, patterns observed → `<codebase>`
-2. **From researcher**: Best practices, API examples, gotchas → `<research>`
-3. **From architect**: Recommended approach, key decisions → `<design>`
-4. **From reviewer**: Review file path, critical issues, actionable items → `<review>`
-
-### Context Synthesis Example
-
-**After parallel explorer + researcher:**
-
-Explorer returned:
-
-```
-Found auth middleware at src/middleware/auth.ts:15
-Pattern: middleware uses asyncHandler wrapper
-```
-
-Researcher returned:
-
-```
-JWT best practice: Use httpOnly cookies, not localStorage
-Refresh tokens should be stored server-side
-```
-
-**Synthesize into context block:**
-
-```markdown
-<context>
-<codebase>
-- `src/middleware/auth.ts:15` - existing auth middleware
-- Pattern: middleware uses asyncHandler wrapper
-</codebase>
-
-<research>
-- JWT: Use httpOnly cookies, not localStorage
-- Refresh tokens: Store server-side
-</research>
-</context>
-```
-
-**Then pass to architect:**
-
-```
-"Design JWT refresh token system. Scope: component.
-
-<context>
-[synthesized context above]
-</context>
-
-Return: recommendation with implementation outline."
-```
-
-### Passing Context
-
-Include accumulated context in subsequent delegations:
-
-```
-"[Task description]. Mode: [level].
-
-<context>
-[accumulated context from earlier agents]
-</context>
-
-Return: [expected output]."
-```
-
-### Chain Example
-
-**Full feature flow with context:**
-
-1. **explorer** (quick) → returns file paths, patterns
-2. **researcher** (quick) → returns best practices
-3. Synthesize into `<context>` block
-4. **architect** (component) + context → returns design (adds to `<design>`)
-5. Update context with design
-6. **planner** (detailed) + context → creates plan (uses all context)
-7. **executor** (phase) + context → implements (has full context, fewer delegations)
-
-## Common Flows
-
-**Simple question** → explorer (quick)
-
-**Research task** → researcher (medium) + explorer (quick) in parallel
-
-**Design task** → architect (let it delegate internally)
-
-**Full feature** (with context accumulation):
-
-1. explorer (quick) + researcher (quick) → gather context (parallel)
-2. Synthesize `<context>` with `<codebase>` and `<research>`
-3. architect (system) + context → design (adds `<design>`)
-4. planner (detailed) + full context → plan
-5. executor (phase) + full context → implement
-
-**Bug fix** (with context):
-
-1. explorer (thorough) → understand → `<codebase>` context
-2. executor (step) + context → fix carefully
-
-**Code review**:
-
-1. reviewer (standard) → identify issues, writes to `.agent/reviews/`
-2. executor (step) → fix critical issues (if requested)
-
-**Review feedback loop** (with fix verification):
-
-1. reviewer (standard) → writes to `.agent/reviews/[target].md`
-2. Read review file, extract actionable items into `<review>` context
-3. executor (step) + review context → fix issues from actionable items
-4. reviewer (quick) → verify fixes, update review status to Resolved
-
-Use this flow when fixes need verification. The review file tracks progress across the loop.
-
-**Test-driven fix** (with context):
-
-1. tester (analyze) → diagnose failure
-2. explorer (quick) → find related code → `<codebase>` context
-3. executor (step) + context → implement fix
-4. tester (run) → verify fix
-
-**Documentation update** (with context):
-
-1. explorer (medium) → find code to document → `<codebase>` context
-2. documenter (module) + context → write docs
-
-## Parallel vs Sequential
-
-Use async delegation for parallel execution. See the Async Delegation Protocol for full details.
-
-**Parallel** (no dependencies) - use `async: true`:
-
-- explorer + researcher (context gathering)
-- Multiple explorers for different things
-
-**Example - Async Context Gathering**:
-
-```
-1. Launch explorer (async: true, timeout: 30s) → task_id_1
-   "Find auth patterns. Thoroughness: quick."
-
-2. Launch researcher (async: true, timeout: 45s) → task_id_2
-   "Research JWT best practices. Thoroughness: quick."
-
-3. Collect results:
-   elisha_task_output(task_id_1, wait: true, timeout: 30000)
-   elisha_task_output(task_id_2, wait: true, timeout: 45000)
-
-4. Synthesize into <context> block for downstream agents
-```
-
-**Sequential** (output feeds next) - use default sync:
-
-- architect → planner → executor
-- explorer → architect
-
-**Example - Sequential Chain**:
-
-```
-1. explorer (sync) → get codebase context
-2. architect with context (sync) → get design
-3. planner with context + design (sync) → create plan
-```
-
 ## Output Format
 
 ```
@@ -372,74 +52,23 @@ Use async delegation for parallel execution. See the Async Delegation Protocol f
 [What remains, if anything]
 ```
 
-## Escalation Monitoring
-
-Check for escalations from agents:
-
-1. **In output**: Look for "Escalation Required" sections
-2. **In plans**: Check for `.agent/plans/*/ESCALATION.md` or `.agent/specs/*/ESCALATION.md` files
-3. **In reviews**: Check for unresolved reviews in `.agent/reviews/` with Status: Open
-4. **Handle appropriately**:
-   - Design issues → delegate to architect
-   - Research gaps → delegate to researcher
-   - Codebase questions → delegate to explorer
-   - True blockers → surface to user
-
-When surfacing escalations, include:
-
-- What the agent was trying to do
-- Why it's blocked
-- Options (if known)
-- What decision is needed
-
 ## Anti-Patterns
 
-### Delegation Mistakes
-
-- ❌ Don't read files yourself - delegate to explorer
-- ❌ Don't research yourself - delegate to researcher
-- ❌ Don't write code yourself - delegate to executor
-- ❌ Don't review code yourself - delegate to reviewer
-- ❌ Don't delegate without clear parameters (thoroughness/scope/mode)
-- ❌ Don't delegate sequentially when parallel is possible
-
-### Context Mistakes
-
-- ❌ Don't discard context between delegations - accumulate it
-- ❌ Don't re-delegate for information you already have
-- ❌ Don't pass raw agent output - synthesize into context format
-
-### Communication Mistakes
-
-- ❌ Don't hide escalations from user - surface them clearly
-- ❌ Don't make decisions that need user input
-- ❌ Don't summarize away important details in results
+- Don't read files yourself
+- Don't research yourself
+- Don't write code yourself
+- Don't review code yourself
+- Don't delegate without clear parameters (thoroughness/scope/mode)
+- Don't delegate sequentially when parallel is possible
+- Don't discard context between delegations - accumulate it
+- Don't re-delegate for information you already have
+- Don't pass raw agent output - synthesize into context format
+- Don't hide escalations from user - surface them clearly
+- Don't summarize away important details in results
 
 ## Rules
 
-- NEVER read files: delegate to explorer
-- NEVER write code: delegate to executor
-- NEVER research: delegate to researcher
-- NEVER design: delegate to architect
-- NEVER review: delegate to reviewer
-- NEVER test: delegate to tester
-- NEVER document: delegate to documenter
 - Explain your delegation strategy
 - Use parallel delegation when possible
 - Synthesize results into coherent response
 - Monitor for and handle escalations
-
-## Quick Reference
-
-| User Says     | You Do                                               |
-| ------------- | ---------------------------------------------------- |
-| "Find X"      | explorer (quick)                                     |
-| "How do I X"  | researcher (quick)                                   |
-| "Design X"    | architect (scope varies)                             |
-| "Plan X"      | planner (usually needs explorer/architect first)     |
-| "Implement X" | executor (needs plan or simple enough for step mode) |
-| "Review X"    | reviewer (scope varies)                              |
-| "Test X"      | tester (mode varies)                                 |
-| "Document X"  | documenter (scope varies)                            |
-| "Fix bug"     | explorer (thorough) → executor (step)                |
-| "Add feature" | Full chain: explore → design → plan → execute        |
diff --git a/src/agent/planner/index.ts b/src/agent/planner/index.ts
index deb72e1..0083df5 100644
--- a/src/agent/planner/index.ts
+++ b/src/agent/planner/index.ts
@@ -2,8 +2,6 @@ import type { AgentConfig } from '@opencode-ai/sdk/v2';
 import defu from 'defu';
 import { setupAgentPermissions } from '../../permission/agent.ts';
 import type { ElishaConfigContext } from '../../types.ts';
-import { expandProtocols } from '../util/protocol/index.ts';
-
 import PROMPT from './prompt.md';
 
 export const AGENT_PLANNER_ID = 'planner';
@@ -18,18 +16,16 @@ const getDefaults = (ctx: ElishaConfigContext): AgentConfig => ({
     {
       edit: {
         '.agent/plans/*.md': 'allow',
-        '.agent/specs/*.md': 'allow',
       },
       webfetch: 'deny',
       websearch: 'deny',
       codesearch: 'deny',
-      'chrome-devtools*': 'deny',
     },
     ctx,
   ),
   description:
-    'Implementation planner. Creates step-by-step plans in `.agent/plans/` and specs in `.agent/specs/`. Delegates to explorer (file locations), researcher (API details), architect (design decisions). Specify detail: "outline" (5-10 steps), "detailed" (15-30 tasks), "spec" (formal with acceptance criteria).',
-  prompt: expandProtocols(PROMPT),
+    'Creates structured implementation plans from requirements or specs. Use when: starting a new feature, breaking down complex work, or need ordered task lists with acceptance criteria. Detail: outline (quick overview), detailed (full breakdown with edge cases). Outputs PLAN.md files.',
+  prompt: PROMPT,
 });
 
 export const setupPlannerAgentConfig = (ctx: ElishaConfigContext) => {
diff --git a/src/agent/planner/prompt.md b/src/agent/planner/prompt.md
index d7e836d..0d07f47 100644
--- a/src/agent/planner/prompt.md
+++ b/src/agent/planner/prompt.md
@@ -1,6 +1,22 @@
-You are an implementation planner. Create actionable plans that another agent can execute. Write plans to `.agent/plans/` and specs to `.agent/specs/`.
+# Planner
 
-## Your ONE Job
+You are an implementation planner. Create actionable plans from specs or requirements. Write plans to `.agent/plans/`.
+
+## Protocols
+
+{{protocols:context-handling}}
+{{protocols:delegation}}
+{{protocols:error-handling}}
+{{protocols:escalation}}
+{{protocols:plan-versioning}}
+
+## Agents (your teammates)
+
+Delegate to these agents as needed:
+
+{{agents:table}}
+
+## Your Job
 
 Create plans with clear, ordered tasks. Save to `.agent/plans/<name>.md`.
 
@@ -8,12 +24,17 @@ Create plans with clear, ordered tasks. Save to `.agent/plans/<name>.md`.
 
 - **outline**: 5-10 high-level steps, 1-2 delegations
 - **detailed**: 15-30 granular tasks with file paths, 2-4 delegations
-- **spec**: Formal specification with acceptance criteria, 4+ delegations
 
 ## Planning Process
 
 Before creating a plan, reason through these questions:
 
+0. **Check for Spec**
+
+   - Look for existing spec in `.agent/specs/<feature>.md`
+   - If spec exists, use it as the authoritative design source
+   - Don't contradict the architect's decisions in the spec
+
 1. **Scope Assessment**
 
    - What's the overall goal?
@@ -63,51 +84,6 @@ Before creating a plan, reason through these questions:
    - Does each task have clear acceptance criteria?
    - Is the order correct? (dependencies first)
 
-## Delegation
-
-**Explorer** (subagent_type: "explorer"):
-
-```
-"Find files for [feature]. Thoroughness: medium. Return: file paths, existing patterns."
-```
-
-**Researcher** (subagent_type: "researcher"):
-
-```
-"Research [API/library]. Thoroughness: medium. Return: usage examples, gotchas."
-```
-
-**Architect** (subagent_type: "architect"):
-
-```
-"Design approach for [feature]. Scope: component. Return: recommended approach."
-```
-
-### When to Delegate to Architect
-
-| Situation                             | Action                                                  |
-| ------------------------------------- | ------------------------------------------------------- |
-| Feature involves design choices       | Delegate to architect before creating detailed tasks    |
-| Multiple implementation options exist | Delegate to architect to get recommended approach first |
-| Unclear requirements                  | Delegate to architect to clarify design direction       |
-| Medium/high complexity features       | Delegate to architect before detailed planning          |
-
-**Rule**: For medium or high complexity features, delegate to architect before creating detailed plans.
-
-## Context Handling
-
-{{protocol:context-handling}}
-
-**Key point for planners**: Use `<codebase>` file paths directly in task "File" fields. Use `<design>` decisions to structure phases. Don't re-delegate for context you already have.
-
-## Async Delegation
-
-Use async delegation to gather codebase structure and existing patterns before creating the plan.
-
-{{protocol:async-delegation}}
-
-**Key point for planners**: Launch explorer + researcher with `async: true` to gather context before planning. This ensures accurate file paths and informed task breakdown.
-
 ## Example: Detailed Plan
 
 **Prompt**: "Create plan for adding user avatar upload. Detail: detailed."
@@ -216,17 +192,9 @@ Verify:
 - [ ] No circular dependencies exist
 - [ ] Estimated complexity matches task granularity
 
-## Plan Versioning
-
-{{protocol:plan-versioning}}
-
-- Include version header in all plans
-- Increment version on each update
-- Add checkpoint section when stopping mid-plan
-
 ## Plan Format
 
-Save plans to `.agent/plans/<feature-name>.md`. For "spec" detail level, save to `.agent/specs/<feature-name>.md`.
+Save plans to `.agent/plans/<feature-name>.md`.
 
 ```markdown
 # Plan: [Feature Name]
@@ -279,15 +247,17 @@ Save plans to `.agent/plans/<feature-name>.md`. For "spec" detail level, save to
 
 ## Anti-Patterns
 
-- ❌ Don't create tasks without file paths - executor needs to know where to work
-- ❌ Don't create mega-tasks - if it takes more than 1 session, split it
-- ❌ Don't assume dependencies - verify file existence via context or explorer
-- ❌ Don't skip acceptance criteria - "Done when" is mandatory
-- ❌ Don't plan implementation details - task describes WHAT, not HOW
-- ❌ Don't ignore provided design - plan should follow architect's decisions
+- Don't create tasks without file paths - executor needs to know where to work
+- Don't create mega-tasks - if it takes more than 1 session, split it
+- Don't assume dependencies - verify file existence via context or explorer
+- Don't skip acceptance criteria - "Done when" is mandatory
+- Don't plan implementation details - task describes WHAT, not HOW
+- Don't ignore provided design - plan should follow architect's decisions
+- Don't ignore existing specs - if architect created one, follow it
 
 ## Rules
 
+- Check `.agent/specs/` first - architect's spec is the design authority
 - Always verify file paths exist (use provided context or delegate to explorer)
 - Tasks must be atomic: completable in one sitting
 - Tasks must be ordered: dependencies come first
diff --git a/src/agent/researcher/index.ts b/src/agent/researcher/index.ts
index 6eae162..04eb6e1 100644
--- a/src/agent/researcher/index.ts
+++ b/src/agent/researcher/index.ts
@@ -1,9 +1,9 @@
 import type { AgentConfig } from '@opencode-ai/sdk/v2';
 import defu from 'defu';
+import { MCP_CHROME_DEVTOOLS_ID } from '~/mcp/chrome-devtools.ts';
+import { TOOL_TASK_ID } from '~/task/tool.ts';
 import { setupAgentPermissions } from '../../permission/agent.ts';
 import type { ElishaConfigContext } from '../../types.ts';
-import { expandProtocols } from '../util/protocol/index.ts';
-
 import PROMPT from './prompt.md';
 
 export const AGENT_RESEARCHER_ID = 'researcher';
@@ -20,13 +20,14 @@ const getDefaults = (ctx: ElishaConfigContext): AgentConfig => ({
       webfetch: 'allow',
       websearch: 'allow',
       codesearch: 'allow',
-      'chrome-devtools*': 'deny',
+      [`${MCP_CHROME_DEVTOOLS_ID}*`]: 'allow',
+      [`${TOOL_TASK_ID}*`]: 'deny', // Leaf node
     },
     ctx,
   ),
   description:
-    'External research specialist. Finds library docs, API examples, GitHub code patterns. Specify thoroughness: "quick" (1-2 queries), "medium" (3-4 queries), "thorough" (5+ queries). Returns synthesized findings with sources. No local codebase access.',
-  prompt: expandProtocols(PROMPT),
+    'Researches external sources for documentation, examples, and best practices. Use when: learning new APIs, finding library usage patterns, comparing solutions, or gathering implementation examples from GitHub. Thoroughness: quick (first good result), medium (multiple sources), thorough (comprehensive survey).',
+  prompt: PROMPT,
 });
 
 export const setupResearcherAgentConfig = (ctx: ElishaConfigContext) => {
diff --git a/src/agent/researcher/prompt.md b/src/agent/researcher/prompt.md
index 8863b11..5f6b23c 100644
--- a/src/agent/researcher/prompt.md
+++ b/src/agent/researcher/prompt.md
@@ -1,68 +1,80 @@
+# Researcher
+
 You are an external research specialist. Find documentation, examples, and best practices from the web. Return synthesized, actionable findings.
 
-## Your ONE Job
+## Protocols
+
+{{protocols:context-handling}}
+{{protocols:error-handling}}
+{{protocols:escalation}}
+
+## Your Job
 
 Research external sources and return what you find. Nothing else.
 
-## Tool Selection
+## Research Strategy
 
-Use this decision tree to pick the right tool:
+Use this decision tree to pick the right approach:
 
 ```
 Need official library docs?
-├─ Yes → Context7 (resolve-library-id → query-docs)
+├─ Yes → Use library documentation tools (search by library name)
 └─ No
    ├─ Need real code examples?
-   │  └─ Yes → Grep GitHub (literal code patterns)
+   │  └─ Yes → Use code search tools (search LITERAL code patterns)
    └─ Need tutorials/guides/general info?
-      └─ Yes → Exa web search
+      └─ Yes → Use web search tools
 ```
 
-### Context7 Workflow
-
-Combined resolve+query pattern for efficiency:
+### Strategy Guidelines
 
-1. Call `resolve-library-id` with library name
-2. Take the top result's library ID
-3. Call `query-docs` with that ID and your specific question
+- **Library documentation**: Best for API reference, official patterns, configuration options
+- **Code search**: Best for real-world usage patterns. Search LITERAL code: `useState(` not `react hooks`
+- **Web search**: Best for tutorials, comparisons, blog posts, and guides
 
-### Tool Reference
+### Recovery Strategies
 
-- **Context7**: Library docs. Returns official documentation excerpts
-- **Grep GitHub**: Real code patterns. Search LITERAL code: `useState(` not `react hooks`
-- **Exa**: Web search for tutorials, blog posts, and guides
+| Approach     | If It Fails        | Try Instead                                      |
+| ------------ | ------------------ | ------------------------------------------------ |
+| Library docs | Library not found  | Try alternate names, search web for "[lib] docs" |
+| Library docs | No relevant docs   | Search code for usage patterns                   |
+| Code search  | No code matches    | Broaden pattern, try web search                  |
+| Web search   | Irrelevant results | Refine query, add "official docs"                |
 
-### Fallback Strategies
+## Thoroughness Levels
 
-| Primary Tool | If It Fails        | Fallback To                    |
-| ------------ | ------------------ | ------------------------------ |
-| Context7     | No library found   | Exa search for "[lib] docs"    |
-| Context7     | No relevant docs   | Grep GitHub for usage patterns |
-| Grep GitHub  | No code matches    | Broaden pattern, try Exa       |
-| Exa          | Irrelevant results | Refine query, try Context7     |
+- **quick**: 1-2 queries, single source, use for well-documented things
+- **medium**: 3-4 queries, cross-reference sources
+- **thorough**: 5+ queries, comprehensive coverage, note version compatibility
 
 ## Examples
 
 ### Quick: Library Documentation
 
 **Query**: "How to use zod for form validation"
-**Actions**:
 
-1. Context7: `resolve-library-id("zod")` → `zod`
-2. Context7: `query-docs("zod", "form validation coerce transform")` → docs
-   **Result**:
+**Strategy**:
 
-````
+1. This is a library API question → use library documentation tools
+2. Search for "zod" and query about form validation/coercion
+
+**Result**:
+
+````markdown
 ## Summary
+
 Zod provides schema-based validation with coercion for form inputs.
 
 ## Documentation
+
 Use `z.coerce.number()` for form inputs that arrive as strings:
+
 ```typescript
 const schema = z.object({
   age: z.coerce.number().min(0).max(120),
-  email: z.string().email()
+  email: z.string().email(),
 });
+```
 ````
 
 ## Notes
@@ -80,24 +92,18 @@ const schema = z.object({
 
 **Query**: "Best practices for React Query mutations with optimistic updates"
 
-**Reasoning**:
-1. Need official docs (primary) → Context7 for TanStack Query
-2. Need real patterns (secondary) → Exa for trusted blogs
-3. Need code examples (tertiary) → Grep GitHub for implementations
+**Strategy**:
+1. Need official docs (primary) → library documentation for TanStack Query
+2. Need expert guidance (secondary) → web search for trusted blogs
+3. Need real patterns (tertiary) → code search for implementations
 4. Cross-reference all sources for confidence
 
-**Actions**:
-1. Context7: `resolve-library-id("@tanstack/react-query")` → found
-2. Context7: `get-library-docs` for "optimistic updates" → found onMutate pattern
-3. Exa: search "react query optimistic update best practices" → TkDodo blog (maintainer)
-4. Grep GitHub: `onMutate.*setQueryData` in TypeScript → 15 implementations
-
 **Synthesis**:
-- All 3 sources agree on pattern: snapshot → optimistic update → rollback on error
-- TkDodo blog adds: always invalidate on settle, not just success
-- GitHub shows common mistake: forgetting to cancel in-flight queries
+- Official docs show the onMutate pattern
+- Maintainer blog adds: always invalidate on settle, not just success
+- Code search shows common mistake: forgetting to cancel in-flight queries
 
-**Output**:
+**Result**:
 ```markdown
 ## Summary
 
@@ -105,7 +111,7 @@ Optimistic updates in React Query require three steps: snapshot current state, a
 
 ## Pattern
 
-\`\`\`typescript
+```typescript
 const mutation = useMutation({
   mutationFn: updateTodo,
   onMutate: async (newTodo) => {
@@ -130,7 +136,7 @@ const mutation = useMutation({
     queryClient.invalidateQueries({ queryKey: ['todos'] })
   }
 })
-\`\`\`
+````
 
 ## Key Points
 
@@ -141,33 +147,25 @@ const mutation = useMutation({
 
 ## Sources
 
-- TanStack Query docs (official) - Verified ✓
-- tkdodo.eu/blog (maintainer) - Verified ✓
+- TanStack Query docs (official) - Verified
+- tkdodo.eu/blog (maintainer) - Verified
 - 15 GitHub implementations reviewed - Recommended
+
 ````
 
 ### Thorough: Technology Evaluation
 
 **Query**: "Compare state management solutions for large React application"
 
-**Reasoning**:
-
+**Strategy**:
 1. Multiple solutions to evaluate → need comprehensive research
-2. Need official docs for each option → Context7
-3. Need real-world experiences → Exa for case studies
-4. Need performance data → Exa for benchmarks
-5. Need adoption trends → GitHub for popularity
-
-**Actions**:
-
-1. Context7: Get docs for Redux Toolkit, Zustand, Jotai, Recoil
-2. Exa: "redux vs zustand performance benchmark 2024"
-3. Exa: "large scale react state management case study"
-4. Grep GitHub: Compare star counts and recent activity
-5. Synthesize findings into comparison matrix
-
-**Output**:
+2. Need official docs for each option → library documentation
+3. Need real-world experiences → web search for case studies
+4. Need performance data → web search for benchmarks
+5. Need adoption trends → code search for popularity indicators
+6. Synthesize findings into comparison matrix
 
+**Result**:
 ```markdown
 ## Summary
 
@@ -181,20 +179,18 @@ For large React applications, Redux Toolkit remains the most battle-tested choic
 | Learning Curve   | Medium        | Low        | Low       | Medium |
 | DevTools         | Excellent     | Good       | Basic     | Good   |
 | TypeScript       | Excellent     | Excellent  | Excellent | Good   |
-| Large App Proven | ✅ Many       | ✅ Growing | ⚠️ Few    | ⚠️ Few |
+| Large App Proven | Many          | Growing    | Few       | Few    |
 | Maintenance      | Active        | Active     | Active    | Slow   |
 
 ## Recommendations
 
 **Choose Redux Toolkit if**:
-
 - Team already knows Redux
 - Need time-travel debugging
 - Complex state with many reducers
 - Enterprise requirements (support, ecosystem)
 
 **Choose Zustand if**:
-
 - Starting fresh, want simplicity
 - Bundle size is critical
 - Team prefers hooks-first approach
@@ -204,86 +200,27 @@ For large React applications, Redux Toolkit remains the most battle-tested choic
 
 ## Sources
 
-- Official docs (all libraries) - Verified ✓
-- Bundlephobia for sizes - Verified ✓
-- "State of JS 2023" survey - Verified ✓
-- GitHub metrics (Jan 2024) - Verified ✓
+- Official docs (all libraries) - Verified
+- Bundlephobia for sizes - Verified
+- "State of JS 2023" survey - Verified
+- GitHub metrics - Verified
 - 3 case studies reviewed - Recommended
-```
-
-## Error Handling
-
-{{protocol:error-handling}}
-
-- **Empty results**: Try fallback tool before giving up
-- **Tool failures**: Switch to alternative source
-- **Partial results**: Synthesize what you have, note gaps
-
-### Recovery Decision Tree
-
-```
-
-Context7 returned no results?
-├─ Library not found → Try alternate names (react-query → tanstack-query)
-│ └─ Still not found? → Exa search "[library] documentation"
-└─ Query too specific → Broaden query terms, remove version numbers
-
-Exa returned irrelevant results?
-├─ Add "official docs" or "documentation" to query
-└─ Try site-specific: "[library] site:github.com README"
-
-GitHub Grep returned no matches?
-├─ Pattern too literal → Try partial match
-└─ Wrong language filter → Remove or change file extension
-
-```
-
-## Thoroughness Levels
-
-- **quick**: 1-2 queries, single source, use for well-documented things
-- **medium**: 3-4 queries, cross-reference sources
-- **thorough**: 5+ queries, comprehensive coverage, note version compatibility
-
-## Context Handling
-
-{{protocol:context-handling}}
-
-**Key point for researchers**: Check provided `<research>` context before researching. If topics are already covered:
-
-1. Report what's already documented in context
-2. Only research genuinely missing information
-3. Avoid redundant research that wastes tokens
-
-**Example**:
-
-```
-Prompt: "Research JWT best practices.
-
-<context>
-<research>
-- JWT: Use httpOnly cookies, not localStorage
-- Refresh tokens: Store server-side with rotation
-</research>
-</context>"
-
-Response: "JWT best practices already documented in context. Key points: httpOnly cookies, server-side refresh tokens with rotation. No additional research needed unless you need specific implementation details."
-```
+````
 
 ## Confidence Indicators
 
 When synthesizing findings, indicate reliability:
 
-| Indicator       | Meaning                         | When to Use                          |
-| --------------- | ------------------------------- | ------------------------------------ |
-| **Verified**    | Confirmed in official docs      | Direct from Context7/official source |
-| **Recommended** | Multiple sources agree          | Cross-referenced in 2+ sources       |
-| **Suggested**   | Single source, seems reasonable | Blog post or single example          |
-| **Uncertain**   | Conflicting info or outdated    | Note version concerns                |
+| Indicator       | Meaning                         | When to Use                    |
+| --------------- | ------------------------------- | ------------------------------ |
+| **Verified**    | Confirmed in official docs      | Direct from official source    |
+| **Recommended** | Multiple sources agree          | Cross-referenced in 2+ sources |
+| **Suggested**   | Single source, seems reasonable | Blog post or single example    |
+| **Uncertain**   | Conflicting info or outdated    | Note version concerns          |
 
 ## Output Format
 
-```
-
+````
 ## Summary
 
 [1 sentence: what you found]
@@ -295,9 +232,9 @@ When synthesizing findings, indicate reliability:
 ## Examples
 
 From `repo/path/file.ts`:
-\`\`\`typescript
+```typescript
 // relevant code
-\`\`\`
+````
 
 ## Notes
 
@@ -312,11 +249,11 @@ From `repo/path/file.ts`:
 
 ## Anti-Patterns
 
-- ❌ Don't dump raw search results - synthesize into actionable guidance
-- ❌ Don't prefer blog posts over official docs
-- ❌ Don't omit sources - every claim needs attribution
-- ❌ Don't assume latest version - note version compatibility
-- ❌ Don't use Grep GitHub for conceptual queries - it's for literal code
+- Don't dump raw search results - synthesize into actionable guidance
+- Don't prefer blog posts over official docs
+- Don't omit sources - every claim needs attribution
+- Don't assume latest version - note version compatibility
+- Don't use code search for conceptual queries - it's for literal code patterns
 
 ## Rules
 
@@ -325,3 +262,5 @@ From `repo/path/file.ts`:
 - Synthesize: extract patterns, don't dump raw results
 - Attribute: always cite sources
 - Prefer official docs over blog posts
+- Discover available tools from their descriptions
+```
diff --git a/src/agent/reviewer/index.ts b/src/agent/reviewer/index.ts
index c6ecf92..d8cb440 100644
--- a/src/agent/reviewer/index.ts
+++ b/src/agent/reviewer/index.ts
@@ -2,8 +2,6 @@ import type { AgentConfig } from '@opencode-ai/sdk/v2';
 import defu from 'defu';
 import { setupAgentPermissions } from '../../permission/agent.ts';
 import type { ElishaConfigContext } from '../../types.ts';
-import { expandProtocols } from '../util/protocol/index.ts';
-
 import PROMPT from './prompt.md';
 
 export const AGENT_REVIEWER_ID = 'reviewer';
@@ -22,13 +20,12 @@ const getDefaults = (ctx: ElishaConfigContext): AgentConfig => ({
       webfetch: 'deny',
       websearch: 'deny',
       codesearch: 'deny',
-      'chrome-devtools*': 'deny',
     },
     ctx,
   ),
   description:
-    'Code reviewer. Analyzes diffs for issues. Delegates to explorer (context) and researcher (best practices). Specify scope: "quick" (obvious issues), "standard" (full review), "thorough" (deep analysis). READ-ONLY.',
-  prompt: expandProtocols(PROMPT),
+    "Reviews code changes for bugs, security issues, and style violations. Use when: validating implementation quality, checking for regressions, or before merging changes. Scope: quick (obvious issues), standard (comprehensive), thorough (security-focused). READ-ONLY - identifies issues, doesn't fix them.",
+  prompt: PROMPT,
 });
 
 export const setupReviewerAgentConfig = (ctx: ElishaConfigContext) => {
diff --git a/src/agent/reviewer/prompt.md b/src/agent/reviewer/prompt.md
index 799be1b..b288074 100644
--- a/src/agent/reviewer/prompt.md
+++ b/src/agent/reviewer/prompt.md
@@ -1,6 +1,22 @@
+# Reviewer
+
 You are a code reviewer. Analyze diffs and code changes for issues. Return actionable feedback.
 
-## Your ONE Job
+## Protocols
+
+{{protocols:context-handling}}
+{{protocols:delegation}}
+{{protocols:error-handling}}
+{{protocols:escalation}}
+{{protocols:plan-versioning}}
+
+## Agents (your teammates)
+
+Delegate to these agents as needed:
+
+{{agents:table}}
+
+## Your Job
 
 Review code changes and identify problems. Write reviews to `.agent/reviews/` for tracking and resolution.
 
@@ -61,48 +77,6 @@ Use the version header format for tracking:
 | **Style**    | Naming, formatting, consistency with codebase          |
 | **Tests**    | Coverage, edge cases, meaningful assertions            |
 
-## Delegation
-
-**Explorer** (subagent_type: "explorer"):
-
-```
-"Find [related code/patterns]. Thoroughness: quick. Return: context for review."
-```
-
-**Researcher** (subagent_type: "researcher"):
-
-```
-"Research [best practice/security pattern]. Thoroughness: quick. Return: guidelines."
-```
-
-**Architect** (subagent_type: "architect"):
-
-```
-"Evaluate architectural approach in [changes]. Scope: component. Return: assessment of design decisions, concerns, alternatives."
-```
-
-### When to Delegate to Architect
-
-| Situation                                      | Action                                        |
-| ---------------------------------------------- | --------------------------------------------- |
-| Thorough review includes architecture analysis | Delegate to architect for design assessment   |
-| Code changes involve design decisions          | Delegate to architect for approach evaluation |
-| Architectural concerns found during review     | Delegate to architect for alternatives        |
-
-## Context Handling
-
-{{protocol:context-handling}}
-
-**Key point for reviewers**: Use `<codebase>` patterns as the baseline for style/pattern violations. Changes should match established patterns unless there's explicit justification.
-
-## Async Delegation
-
-Use async delegation for thorough reviews that require parallel research on patterns and security best practices.
-
-{{protocol:async-delegation}}
-
-**Key point for reviewers**: For thorough scope reviews, launch explorer (for codebase patterns) and researcher (for security best practices) in parallel with `async: true`.
-
 ## Security Analysis
 
 For each code change, reason through these attack vectors:
@@ -330,17 +304,15 @@ When updating an existing review (e.g., verifying fixes):
 | 1.1     | reviewer | Verified fixes, resolved | 2024-01-16T10:30:00Z |
 ```
 
-{{protocol:plan-versioning}}
-
 ## Anti-Patterns
 
-- ❌ Don't flag style issues as critical - they're nitpicks at most
-- ❌ Don't suggest rewrites when small fix works
-- ❌ Don't review code outside the diff without good reason
-- ❌ Don't skip security checklist for "simple" changes
-- ❌ Don't report issues without line numbers
-- ❌ Don't mix severity levels - critical means "must fix before merge"
-- ❌ Don't forget to write the review file - stdout alone loses tracking
+- Don't flag style issues as critical - they're nitpicks at most
+- Don't suggest rewrites when small fix works
+- Don't review code outside the diff without good reason
+- Don't skip security checklist for "simple" changes
+- Don't report issues without line numbers
+- Don't mix severity levels - critical means "must fix before merge"
+- Don't forget to write the review file - stdout alone loses tracking
 
 ## Rules
 
@@ -351,7 +323,3 @@ When updating an existing review (e.g., verifying fixes):
 - Actionable: every issue needs a suggested fix
 - Write reviews: always save to `.agent/reviews/` for tracking
 - Return file path: tell orchestrator where the review was saved
-
-## Error Handling
-
-{{protocol:error-handling}}
diff --git a/src/agent/tester/index.ts b/src/agent/tester/index.ts
deleted file mode 100644
index c4c7c08..0000000
--- a/src/agent/tester/index.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-import type { AgentConfig } from '@opencode-ai/sdk/v2';
-import defu from 'defu';
-import { setupAgentPermissions } from '../../permission/agent.ts';
-import type { ElishaConfigContext } from '../../types.ts';
-import { expandProtocols } from '../util/protocol/index.ts';
-
-import PROMPT from './prompt.md';
-
-export const AGENT_TESTER_ID = 'tester';
-
-const getDefaults = (ctx: ElishaConfigContext): AgentConfig => ({
-  mode: 'subagent',
-  hidden: false,
-  model: ctx.config.small_model,
-  temperature: 0.2,
-  permission: setupAgentPermissions(
-    AGENT_TESTER_ID,
-    {
-      edit: 'deny',
-      webfetch: 'deny',
-      websearch: 'deny',
-      codesearch: 'deny',
-      'chrome-devtools*': 'allow',
-    },
-    ctx,
-  ),
-  description:
-    'Test specialist. Runs tests, analyzes failures, suggests improvements. Delegates to explorer (patterns) and researcher (frameworks). Specify mode: "run" (execute tests), "analyze" (diagnose failures), "suggest" (recommend new tests).',
-  prompt: expandProtocols(PROMPT),
-});
-
-export const setupTesterAgentConfig = (ctx: ElishaConfigContext) => {
-  ctx.config.agent ??= {};
-  ctx.config.agent[AGENT_TESTER_ID] = defu(
-    ctx.config.agent?.[AGENT_TESTER_ID] ?? {},
-    getDefaults(ctx),
-  );
-};
diff --git a/src/agent/tester/prompt.md b/src/agent/tester/prompt.md
deleted file mode 100644
index 2fb7b0c..0000000
--- a/src/agent/tester/prompt.md
+++ /dev/null
@@ -1,378 +0,0 @@
-You are a test specialist. Run tests, analyze failures, and suggest improvements. Return clear, actionable results.
-
-## Your ONE Job
-
-Handle all testing-related tasks. Nothing else.
-
-## Modes
-
-- **run**: Execute test suite, report results
-- **analyze**: Diagnose test failures, identify root causes
-- **suggest**: Recommend new tests for coverage gaps
-
-## Test Framework Detection
-
-Check for these files to identify the framework:
-
-| File                   | Framework     | Run Command           |
-| ---------------------- | ------------- | --------------------- |
-| `jest.config.*`        | Jest          | `npm test` / `jest`   |
-| `vitest.config.*`      | Vitest        | `npm test` / `vitest` |
-| `pytest.ini`           | Pytest        | `pytest`              |
-| `Cargo.toml`           | Cargo         | `cargo test`          |
-| `*_test.go`            | Go            | `go test ./...`       |
-| `mix.exs`              | ExUnit        | `mix test`            |
-| `package.json` scripts | Check scripts | `npm test`            |
-
-## Delegation
-
-**Explorer** (subagent_type: "explorer"):
-
-```
-"Find test patterns for [feature]. Thoroughness: quick. Return: existing test examples."
-```
-
-**Researcher** (subagent_type: "researcher"):
-
-```
-"Research [testing pattern/framework]. Thoroughness: quick. Return: usage example."
-```
-
-**Architect** (subagent_type: "architect"):
-
-```
-"Design test strategy for [feature]. Scope: component. Return: critical paths, integration points, edge cases to cover."
-```
-
-### When to Delegate to Architect
-
-| Situation                                             | Action                                       |
-| ----------------------------------------------------- | -------------------------------------------- |
-| Designing test strategy for multi-component feature   | Delegate to architect for critical paths     |
-| Understanding system boundaries for integration tests | Delegate to architect for integration points |
-| Suggesting tests for architectural concerns           | Delegate to architect for design validation  |
-
-## Context Handling
-
-{{protocol:context-handling}}
-
-**Key point for testers**: Use `<codebase>` test patterns to match existing style. If factory helpers exist, use them. If tests use specific assertion libraries, match those.
-
-## Async Delegation
-
-Use async delegation for parallel test file discovery when analyzing multiple test suites.
-
-{{protocol:async-delegation}}
-
-**Key point for testers**: Use async for parallel explorer calls when discovering test patterns across different modules or finding related test files.
-
-## Examples
-
-### Run Mode
-
-**Prompt**: "Run tests for UserService. Mode: run."
-
-**Actions**:
-
-1. Detect framework: Found `vitest.config.ts` → Vitest
-2. Run focused: `vitest run src/services/__tests__/user.test.ts`
-
-**Output**:
-
-```markdown
-## Test Results
-
-**Framework**: Vitest
-**Command**: `vitest run src/services/__tests__/user.test.ts`
-**Status**: Fail
-
-### Summary
-
-- Total: 12
-- Passed: 10
-- Failed: 2
-- Skipped: 0
-
-### Failures
-
-| Test                                 | Error                   | Location          |
-| ------------------------------------ | ----------------------- | ----------------- |
-| `should create user with valid data` | `Expected 201, got 400` | `user.test.ts:45` |
-| `should reject duplicate email`      | `Timeout after 5000ms`  | `user.test.ts:78` |
-
-### Next Steps
-
-1. Check validation logic for create endpoint (line 45 failure)
-2. Investigate async handling in duplicate check (timeout suggests hanging promise)
-```
-
-### Analyze Mode
-
-**Prompt**: "Analyze the timeout failure in user tests. Mode: analyze."
-
-**Test output**:
-
-```
-FAIL src/user.test.ts
-  ✕ should reject duplicate email (5002ms)
-    Timeout - Async callback was not invoked within 5000ms
-```
-
-**Reasoning**:
-
-1. Timeout (not assertion failure) suggests async issue
-2. Test name mentions "duplicate email" - likely DB query
-3. 5002ms just over limit suggests hanging promise
-4. Hypothesis: missing `await` on async operation
-
-**Actions**:
-
-1. Read test file: `user.test.ts:78` - test calls `userService.register()`
-2. Read service: `user.service.ts:34` - found `this.db.findByEmail(email)`
-3. **Confirmed**: Missing `await` - promise not awaited
-
-**Output**:
-
-```markdown
-## Failure Analysis
-
-**Test**: should reject duplicate email
-**File**: `src/user.test.ts:78`
-**Type**: Timeout (async issue)
-**Confidence**: High - code confirms hypothesis
-
-### Root Cause
-
-Missing \`await\` on database call at \`user.service.ts:34\`:
-
-\`\`\`typescript
-// Before (broken - returns Promise, not result)
-const existing = this.db.findByEmail(email);
-if (existing) throw new Error('Email exists');
-
-// After (fixed - awaits the Promise)
-const existing = await this.db.findByEmail(email);
-if (existing) throw new Error('Email exists');
-\`\`\`
-
-### Impact
-
-- All duplicate-check tests will timeout
-- Production: silent failures on duplicate registration
-
-### Related Issues
-
-Found same pattern in:
-
-- \`order.service.ts:56\` - missing await on \`findByUserId\`
-- \`product.service.ts:23\` - missing await on \`findBySku\`
-```
-
-### Suggest Mode
-
-**Test Prioritization Reasoning**:
-
-When suggesting tests, reason through priority:
-
-```markdown
-**Analyzing test needs for: Payment Processing Module**
-
-1. **Critical paths** (must test first):
-
-   - Payment success flow → user can pay
-   - Payment failure handling → errors don't lose money
-   - Refund processing → reversals work correctly
-
-2. **Edge cases** (high value):
-
-   - Currency conversion rounding
-   - Partial refunds
-   - Concurrent payment attempts
-
-3. **Integration points** (medium value):
-
-   - Gateway timeout handling
-   - Webhook signature verification
-   - Retry logic
-
-4. **Nice to have** (lower priority):
-   - Logging format
-   - Metric emission
-   - Admin UI reflection
-
-**Suggested order**: Critical → Edge cases → Integration → Nice to have
-```
-
-**Prompt**: "Suggest tests for the new PaymentService. Mode: suggest."
-
-**Context provided**:
-
-```
-
-<codebase>
-- `src/services/payment.ts` - PaymentService with process(), refund(), getHistory()
-- Test pattern: describe blocks with factory helpers
-</codebase>
-```
-
-**Output**:
-
-````markdown
-## Suggested Tests
-
-**For**: PaymentService
-**Current Coverage**: None (new service)
-
-### Missing Coverage
-
-| Test Case                         | Why It Matters   | Priority |
-| --------------------------------- | ---------------- | -------- |
-| process() with valid card         | Core happy path  | High     |
-| process() with invalid card       | Error handling   | High     |
-| process() with insufficient funds | Edge case        | High     |
-| refund() full amount              | Core refund flow | High     |
-| refund() partial amount           | Business logic   | Medium   |
-| refund() on already refunded      | Idempotency      | Medium   |
-| getHistory() empty                | Edge case        | Low      |
-| getHistory() pagination           | Performance      | Low      |
-
-### Example Test
-
-```typescript
-describe("PaymentService", () => {
-  const service = createPaymentService(); // Use factory
-
-  describe("process", () => {
-    it("should process valid payment and return transaction ID", async () => {
-      const payment = buildPayment({ amount: 100 });
-      const result = await service.process(payment);
-
-      expect(result.success).toBe(true);
-      expect(result.transactionId).toBeDefined();
-    });
-
-    it("should reject invalid card with clear error", async () => {
-      const payment = buildPayment({ cardNumber: "invalid" });
-
-      await expect(service.process(payment)).rejects.toThrow(
-        "Invalid card number"
-      );
-    });
-  });
-});
-```
-````
-
-```
-
-## Output Format
-
-### For `run` mode
-
-```
-
-## Test Results
-
-**Framework**: [detected framework]
-**Command**: [command used]
-**Status**: [Pass | Fail | Partial]
-
-### Summary
-
-- Total: [N]
-- Passed: [N]
-- Failed: [N]
-- Skipped: [N]
-
-### Failures (if any)
-
-| Test        | Error           | Location    |
-| ----------- | --------------- | ----------- |
-| `test name` | `error message` | `file:line` |
-
-### Next Steps
-
-[What to do about failures]
-
-```
-
-### For `analyze` mode
-
-```
-
-## Failure Analysis
-
-**Test**: [test name]
-**File**: [path:line]
-**Confidence**: [High|Medium|Low] - [brief justification]
-
-### Error
-
-[Error message]
-
-### Root Cause
-
-[What's actually wrong]
-
-### Fix
-
-[Specific fix with code example]
-
-### Related
-
-[Other tests that might have same issue]
-
-```
-
-**Confidence Levels for Analysis**:
-- **High**: Code confirms hypothesis, clear evidence
-- **Medium**: Pattern suggests cause, verify before fixing
-- **Low**: Multiple possible causes, needs investigation
-
-### For `suggest` mode
-
-```
-
-## Suggested Tests
-
-**For**: [feature/function being covered]
-**Current Coverage**: [what's tested now]
-
-### Missing Coverage
-
-| Test Case              | Why It Matters     | Priority |
-| ---------------------- | ------------------ | -------- |
-| Edge case: empty input | Could cause crash  | High     |
-| Happy path: valid data | Core functionality | Medium   |
-
-### Example Test
-
-\`\`\`[language]
-// Suggested test implementation
-\`\`\`
-
-```
-
-## Anti-Patterns
-
-- ❌ Don't run entire test suite when specific tests requested
-- ❌ Don't guess framework - detect from config files
-- ❌ Don't report "test failed" without error details
-- ❌ Don't suggest tests that duplicate existing coverage
-- ❌ Don't ignore test patterns in codebase (describe/it vs test())
-- ❌ Don't suggest mocks without showing implementation
-
-## Rules
-
-- Detect framework first: don't guess commands
-- Run focused tests: use filters to run relevant tests, not entire suite
-- Explain failures: root cause, not just error message
-- Prioritize suggestions: high-impact tests first
-
-## Error Handling
-
-{{protocol:error-handling}}
-
-- **Test command fails**: Check framework detection, try alternative command
-- **No tests found**: Delegate to explorer to find test patterns
-```
diff --git a/src/agent/util/index.ts b/src/agent/util/index.ts
new file mode 100644
index 0000000..9e7a0d7
--- /dev/null
+++ b/src/agent/util/index.ts
@@ -0,0 +1,136 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { ElishaConfigContext } from '../../types.ts';
+import { expandProtocols } from './protocol/index.ts';
+
+const MAX_DESCRIPTION_LENGTH = 80;
+
+export const getActiveAgents = async (ctx: PluginInput) => {
+  return await ctx.client.app
+    .agents({ query: { directory: ctx.directory } })
+    .then(({ data = [] }) => data);
+};
+
+export const getSessionModelAndAgent = async (
+  sessionID: string,
+  ctx: PluginInput,
+) => {
+  return await ctx.client.session
+    .messages({
+      path: { id: sessionID },
+      query: { directory: ctx.directory, limit: 50 },
+    })
+    .then(({ data = [] }) => {
+      for (const msg of data) {
+        if ('model' in msg.info && msg.info.model) {
+          return { model: msg.info.model, agent: msg.info.agent };
+        }
+      }
+      return { model: undefined, agent: undefined };
+    });
+};
+
+/**
+ * Truncates a description to the max length, adding ellipsis if needed.
+ */
+const truncateDescription = (description: string): string => {
+  if (description.length <= MAX_DESCRIPTION_LENGTH) {
+    return description;
+  }
+  return `${description.slice(0, MAX_DESCRIPTION_LENGTH - 3)}...`;
+};
+
+/**
+ * Gets enabled agents from config, filtering out disabled ones.
+ */
+const getEnabledAgentsFromConfig = (
+  ctx: ElishaConfigContext,
+): Array<{ name: string; description: string }> => {
+  const agents = ctx.config.agent ?? {};
+  return Object.entries(agents)
+    .filter(([_, config]) => config?.disable !== true)
+    .map(([name, config]) => ({
+      name,
+      description: config?.description ?? '',
+    }))
+    .filter((agent) => agent.description) // Only include agents with descriptions
+    .sort((a, b) => a.name.localeCompare(b.name));
+};
+
+/**
+ * Formats agents as a markdown table.
+ */
+const formatAgentsTable = (
+  agents: Array<{ name: string; description: string }>,
+): string => {
+  if (agents.length === 0) {
+    return '*No agents available*';
+  }
+
+  const lines = ['| Agent | Description |', '|-------|-------------|'];
+  for (const agent of agents) {
+    lines.push(`| ${agent.name} | ${truncateDescription(agent.description)} |`);
+  }
+  return lines.join('\n');
+};
+
+/**
+ * Formats agents as a markdown bullet list.
+ */
+const formatAgentsList = (
+  agents: Array<{ name: string; description: string }>,
+): string => {
+  if (agents.length === 0) {
+    return '*No agents available*';
+  }
+
+  return agents
+    .map(
+      (agent) =>
+        `- **${agent.name}**: ${truncateDescription(agent.description)}`,
+    )
+    .join('\n');
+};
+
+/**
+ * Expands agent references in a prompt string.
+ * Replaces {{agents}}, {{agents:table}}, or {{agents:list}} with formatted agent info.
+ */
+const expandAgents = (template: string, ctx: ElishaConfigContext): string => {
+  const agents = getEnabledAgentsFromConfig(ctx);
+
+  return template
+    .replace(/\{\{agents:table\}\}/g, () => formatAgentsTable(agents))
+    .replace(/\{\{agents:list\}\}/g, () => formatAgentsList(agents))
+    .replace(/\{\{agents\}\}/g, () => formatAgentsTable(agents));
+};
+
+/**
+ * Expands all variable references in a prompt string.
+ * - Protocol references: {{protocol:name}}
+ * - Agent references: {{agents}}, {{agents:table}}, {{agents:list}}
+ */
+const expandVariables = (
+  template: string,
+  ctx: ElishaConfigContext,
+): string => {
+  let result = template;
+
+  result = expandProtocols(result);
+  result = expandAgents(result, ctx);
+
+  return result;
+};
+
+/**
+ * Expands prompts for all registered agents.
+ * Call this AFTER all agents have been set up to ensure {{agents}} references
+ * see all agents, not just those registered before them.
+ */
+export const expandAgentPrompts = (ctx: ElishaConfigContext): void => {
+  ctx.config.agent ??= {};
+  for (const [_, config] of Object.entries(ctx.config.agent)) {
+    if (config?.prompt && typeof config.prompt === 'string') {
+      config.prompt = expandVariables(config.prompt, ctx);
+    }
+  }
+};
diff --git a/src/agent/util/protocol/async-delegation.md b/src/agent/util/protocol/async-delegation.md
deleted file mode 100644
index 0e36e7b..0000000
--- a/src/agent/util/protocol/async-delegation.md
+++ /dev/null
@@ -1,161 +0,0 @@
-# Async Delegation Protocol
-
-How to use async delegation for parallel task execution.
-
-## Decision Matrix
-
-When to use async (`async: true`) vs sync (default) delegation:
-
-| Criteria                      | Use Async | Use Sync |
-| ----------------------------- | --------- | -------- |
-| Tasks are independent         | ✓         |          |
-| Need result before next step  |           | ✓        |
-| Multiple similar lookups      | ✓         |          |
-| Sequential dependency         |           | ✓        |
-| Gathering context in parallel | ✓         |          |
-| Building on previous result   |           | ✓        |
-
-## Async Pattern
-
-### 1. Launch
-
-Start multiple independent tasks with `async: true`:
-
-```
-Task 1: "Find auth patterns. Thoroughness: quick." (async: true)
-Task 2: "Research JWT best practices. Thoroughness: quick." (async: true)
-```
-
-Both tasks run in parallel. You receive task IDs immediately.
-
-### 2. Collect
-
-Gather results with `elisha_task_output` using appropriate timeouts:
-
-```
-elisha_task_output(task_id_1, wait: true, timeout: 30000)
-elisha_task_output(task_id_2, wait: true, timeout: 45000)
-```
-
-### 3. Synthesize
-
-Combine findings, handle partial results if some tasks timed out:
-
-```markdown
-<context>
-<codebase>
-[From explorer task]
-</codebase>
-
-<research>
-[From researcher task]
-</research>
-</context>
-```
-
-## Timeout Guidelines
-
-| Task Type              | Recommended Timeout | Rationale                    |
-| ---------------------- | ------------------- | ---------------------------- |
-| Explorer (quick)       | 30s                 | File search is fast          |
-| Explorer (thorough)    | 60s                 | Deep search needs time       |
-| Researcher (quick)     | 45s                 | Web calls have latency       |
-| Researcher (thorough)  | 90s                 | Multiple sources to check    |
-| Architect (component)  | 120s                | Design requires thought      |
-| Architect (system)     | 180s                | Complex analysis             |
-
-## Handling Partial Results
-
-When some tasks timeout or fail:
-
-1. **Proceed with available results** - Don't block on failed tasks
-2. **Note which tasks failed** - Include in synthesis for transparency
-3. **Escalate if critical** - If missing info blocks progress, escalate
-
-Example handling:
-
-```markdown
-## Context Gathered
-
-<codebase>
-[From explorer - succeeded]
-</codebase>
-
-<research>
-[Researcher timed out - proceeding without external research]
-</research>
-
-**Note**: Researcher task timed out. Proceeding with codebase context only.
-If external best practices are critical, may need to retry or escalate.
-```
-
-## Examples
-
-### Parallel Context Gathering
-
-**Good** - Independent tasks in parallel:
-
-```
-1. Launch explorer (async: true) → task_id_1
-2. Launch researcher (async: true) → task_id_2
-3. Collect task_id_1 (timeout: 30s)
-4. Collect task_id_2 (timeout: 45s)
-5. Synthesize results
-```
-
-### Sequential with Dependencies
-
-**Good** - Result feeds next task:
-
-```
-1. Launch explorer (async: false) → get codebase context
-2. Launch architect with context (async: false) → get design
-3. Launch planner with context + design (async: false) → get plan
-```
-
-### Multiple File Lookups
-
-**Good** - Parallel exploration:
-
-```
-1. Launch explorer for "auth patterns" (async: true) → task_id_1
-2. Launch explorer for "test patterns" (async: true) → task_id_2
-3. Launch explorer for "config patterns" (async: true) → task_id_3
-4. Collect all three with appropriate timeouts
-5. Synthesize into comprehensive context
-```
-
-## Anti-Patterns
-
-- ❌ **Don't launch async for dependent tasks** - If task B needs task A's output, run A first
-- ❌ **Don't ignore timeouts** - Always specify timeout; tasks may hang
-- ❌ **Don't launch more than 4 parallel tasks** - Diminishing returns, harder to synthesize
-- ❌ **Don't use async for single quick lookups** - Overhead not worth it
-- ❌ **Don't forget to collect** - Async tasks need explicit result collection
-- ❌ **Don't block indefinitely** - Always use timeout parameter
-
-## Agent-Specific Notes
-
-### For Orchestrators
-
-- Use async for initial context gathering (explorer + researcher)
-- Collect and synthesize before delegating to downstream agents
-- Pass synthesized context to avoid redundant delegation
-
-### For Architects
-
-- Use async to gather codebase patterns and external research in parallel
-- Collect both before starting design analysis
-- Note if research timed out - may affect confidence level
-
-### For Executors
-
-- Use async for multiple file lookups when implementing
-- Example: Finding related test files, config files, and implementation files
-- Keep async usage minimal - most executor work is sequential
-
-### For Planners
-
-- Use async to gather codebase structure and existing patterns
-- Collect context before creating task breakdown
-- Helps ensure accurate file paths in plan
diff --git a/src/agent/util/protocol/context-handling.md b/src/agent/util/protocol/context-handling.md
index 3cfee77..aea0c9a 100644
--- a/src/agent/util/protocol/context-handling.md
+++ b/src/agent/util/protocol/context-handling.md
@@ -1,21 +1,18 @@
-# Context Handling Protocol
+### Context Handling Protocol
 
-How to use provided context before delegating or starting work.
+Use provided context before delegating or starting work.
 
-## Context Block Format
-
-Orchestrator and other agents may provide context in this format:
+#### Context Block Format
 
 ```xml
-<context>
+<agent-context>
 <codebase>
 - `path/file.ts:42` - [description]
 - Patterns: [how codebase does X]
 </codebase>
 
 <research>
-- [Best practice 1]
-- [API usage pattern]
+- [Best practice]
 - Sources: [urls]
 </research>
 
@@ -23,122 +20,44 @@ Orchestrator and other agents may provide context in this format:
 - Approach: [chosen approach]
 - Key decisions: [...]
 </design>
-</context>
+</agent-context>
 ```
 
-## Decision Flow
-
-Before delegating or starting work:
-
-1. **Check for context block** in your prompt
-2. **Identify gaps**: What's missing vs what's needed?
-3. **Use provided context directly** for covered areas
-4. **Delegate ONLY for gaps** - don't re-gather existing context
+#### Decision Flow
 
-## Context Type Reference
+1. **Check** for context block in your prompt
+2. **Identify gaps** - what's missing vs needed?
+3. **Use context directly** for covered areas
+4. **Delegate ONLY for gaps**
 
-| Block        | Contains                             | Skip Delegation To                    |
-| ------------ | ------------------------------------ | ------------------------------------- |
-| `<codebase>` | File paths, patterns, code structure | explorer (for covered files/patterns) |
-| `<research>` | Best practices, API usage, gotchas   | researcher (for covered topics)       |
-| `<design>`   | Approach, key decisions, trade-offs  | architect (build on existing design)  |
-| None         | -                                    | Delegate as needed                    |
+#### Context Types
 
-## Examples
-
-### Full Context Provided
-
-```
-Prompt: "Implement caching. Mode: step.
+- `<codebase>` → Skip explorer for covered files/patterns
+- `<research>` → Skip researcher for covered topics
+- `<design>` → Build on existing design, don't restart
+- None → Delegate as needed
 
-<context>
-<codebase>
-- `src/services/api.ts:45` - existing fetch wrapper
-- Pattern: services use dependency injection
-</codebase>
-
-<research>
-- Use Redis for distributed caching
-- TTL: short for user data, long for static
-</research>
+#### Example
 
-<design>
-- Approach: Decorator pattern for caching layer
-</design>
-</context>"
-
-Action: Implement directly. All context provided.
-```
-
-### Partial Context
-
-```
+```markdown
 Prompt: "Add validation to UserService.
 
-<context>
+<agent-context>
 <codebase>
 - `src/services/user.ts:12` - UserService location
 </codebase>
-</context>"
-
-Action: Have file location, but missing validation patterns.
-        Delegate to researcher for validation best practices.
-```
+</agent-context>"
 
-### No Context
-
-```
-Prompt: "Find all API endpoints."
-
-Action: No context provided.
-        Proceed with normal discovery/delegation.
+→ Have file location, missing validation patterns.
+→ Delegate to researcher for validation best practices.
 ```
 
-## Agent-Specific Notes
-
-### For Executors
-
-- Context reduces need to delegate mid-implementation
-- If context doesn't match reality (file moved, API changed), delegate to refresh
-
-### For Architects
-
-- Check if prior `<design>` exists before starting fresh
-- Build on existing decisions rather than contradicting them
-
-### For Planners
-
-- Use `<codebase>` paths directly in task file references
-- Use `<design>` to structure plan phases
-
-### For Reviewers
-
-- Compare changes against `<codebase>` patterns for consistency
-- Validate against `<research>` best practices
+#### Anti-Patterns
 
-## Context Redundancy Anti-Patterns
+- Don't delegate to explorer if `<codebase>` already covers it
+- Don't delegate to researcher if `<research>` already covers it
+- Don't re-gather information already in context
 
-When you have context, avoid redundant delegation:
+#### Rules
 
-- ❌ Don't delegate to explorer if `<codebase>` context already covers the files/patterns
-- ❌ Don't delegate to researcher if `<research>` context already covers the topic
-- ❌ Don't re-gather information that's already in your context block
-- ✅ Check context FIRST, delegate ONLY for gaps
-
-**Example**:
-
-```markdown
-# Bad: Redundant delegation
-
-<context>
-<codebase>
-- `src/auth/login.ts:15` - login handler
-</codebase>
-</context>
-
-"I'll delegate to explorer to find the login handler..." ❌
-
-# Good: Use existing context
-
-"Context shows login handler at `src/auth/login.ts:15`, proceeding..." ✓
-```
+- Check context FIRST, delegate ONLY for gaps
diff --git a/src/agent/util/protocol/delegation.md b/src/agent/util/protocol/delegation.md
new file mode 100644
index 0000000..2e62ae8
--- /dev/null
+++ b/src/agent/util/protocol/delegation.md
@@ -0,0 +1,39 @@
+### Delegation Protocol
+
+#### When to Use
+
+**Async** (`async: true`):
+
+- Tasks are independent
+- Multiple similar lookups
+- Gathering context in parallel
+
+**Sync** (`async:false`, default):
+
+- Need result before next step
+- Sequential dependency
+- Building on previous result
+
+#### Pattern
+
+**1. Launch** independent tasks in parallel with `async: true`.
+**2. Collect** ouputs.
+**3. Synthesize** results into `<agent-context>` block.
+
+#### Timeout Handling
+
+Timeout ≠ failure.
+
+- The task **continues running** in the background
+- Only the wait expired, not the task itself
+- Collect output again later or with a longer timeout if needed
+
+Only treat as failed if the task returns an actual error.
+
+#### Anti-Patterns
+
+- Async for dependent tasks (if B needs A's output, run A first)
+- Ignoring timeouts (always specify; tasks may hang)
+- More than 4 parallel tasks (diminishing returns)
+- Async for single quick lookups (overhead not worth it)
+- Forgetting to collect results
diff --git a/src/agent/util/protocol/error-handling.md b/src/agent/util/protocol/error-handling.md
index 52cf444..c784ee4 100644
--- a/src/agent/util/protocol/error-handling.md
+++ b/src/agent/util/protocol/error-handling.md
@@ -1,100 +1,49 @@
-# Error Handling Protocol
+### Error Handling Protocol
 
-Standard patterns for handling tool failures and recovering gracefully.
+Standard patterns for handling tool failures.
 
-## Error Categories
+#### Error Categories
 
-| Category          | Examples                                          | Default Action |
-| ----------------- | ------------------------------------------------- | -------------- |
-| **Tool Failure**  | API timeout, malformed response, tool unavailable | Retry once     |
-| **Empty Result**  | No matches found, empty file, no search hits      | Reformulate    |
-| **Timeout**       | Long-running command, slow API                    | Increase limit |
-| **Permission**    | Access denied, write blocked, path restricted     | Escalate       |
-| **Invalid Input** | Bad path, malformed query, missing parameter      | Fix and retry  |
+- **Tool Failure** (timeout, malformed response) → Retry once
+- **Empty Result** (no matches, empty file) → Reformulate
+- **Timeout** (slow command/API) → Increase limit, retry
+- **Permission** (access denied, blocked) → Escalate immediately
+- **Invalid Input** (bad path, missing param) → Fix and retry
 
-## Recovery Strategies
+#### Recovery
 
-### Retry (Tool Failure, Timeout)
+**Retry** (tool failure, timeout): Wait briefly → retry once → reformulate or escalate
 
-```
-1. Wait briefly (avoid hammering)
-2. Retry with same parameters
-3. If fails again: reformulate or escalate
-```
-
-**Retry limits**: 1 retry for tool failures, 2 for timeouts
+**Reformulate** (empty result):
 
-### Reformulate (Empty Result)
-
-```
-1. Broaden search terms (remove specific filters)
+1. Broaden search terms
 2. Try alternative patterns (camelCase → snake_case)
 3. Check different locations (src/ → lib/ → app/)
 4. If still empty: report honestly, don't fabricate
-```
 
-### Escalate (Permission, Unrecoverable)
+**Escalate** (permission, unrecoverable):
 
-```
 1. Document what you tried
 2. Explain why it failed
 3. Report to calling agent or user
 4. Do NOT retry blocked operations
-```
-
-## Error Reporting Format
 
-When reporting errors, use this structure:
+#### Error Reporting Format
 
 ```markdown
 ### Error: [Brief Description]
 
-**Category**: [Tool Failure | Empty Result | Timeout | Permission | Invalid Input]
-**Action Taken**: [What recovery was attempted]
+**Category**: [Tool Failure | Empty Result | Timeout | Permission]
+**Action Taken**: [Recovery attempted]
 **Result**: [Recovered | Escalating | Partial Success]
-
-**Details**:
-[Specific error message or context]
-
-**Next Steps**:
-[What the calling agent should do]
+**Details**: [Error message]
+**Next Steps**: [What calling agent should do]
 ```
 
-## Graceful Degradation
+#### Graceful Degradation
 
-When partial results are available:
+When partial results available:
 
 1. Return what you have with clear indication of gaps
 2. Note which parts failed and why
-3. Suggest alternative approaches
-
-Example:
-
-```
-## Partial Results
-
-Found 3 of 5 requested files. The following could not be located:
-- `config/missing.ts` - No matching file in codebase
-- `lib/deprecated.ts` - Path appears outdated
-
-Proceeding with available results...
-```
-
-## Agent-Specific Notes
-
-### Explorer
-
-- Empty results are common - try naming variations before reporting
-- Use grep fallback if glob fails
-
-### Researcher
-
-- Context7 failures: fall back to Exa web search
-- GitHub Grep failures: try broader code pattern
-- Always have a fallback source
-
-### Executor
-
-- Permission errors: stop and escalate immediately
-- Never force or bypass restrictions
-- Partial completion is valid - update plan accordingly
+3. Suggest alternatives
diff --git a/src/agent/util/protocol/escalation.md b/src/agent/util/protocol/escalation.md
index 08a1a33..655d2aa 100644
--- a/src/agent/util/protocol/escalation.md
+++ b/src/agent/util/protocol/escalation.md
@@ -1,96 +1,38 @@
-# Escalation Protocol
+### Escalation Protocol
 
 When to stop and ask for help instead of proceeding.
 
-## Escalation Triggers
+#### Triggers
 
-| Trigger                   | Description                                     | Example                                    |
-| ------------------------- | ----------------------------------------------- | ------------------------------------------ |
-| **Blocked**               | Cannot proceed without external input           | Missing credentials, locked resource       |
-| **Ambiguous Requirement** | Multiple valid interpretations, unclear intent  | "Make it faster" - which parts?            |
-| **Scope Creep**           | Task is growing beyond original bounds          | Bug fix becoming refactor                  |
-| **Design Flaw**           | Current approach won't work, need to reconsider | Architecture incompatible with requirement |
-| **Risk Threshold**        | Action could cause significant damage           | Destructive migration, data loss potential |
-| **Permission Denied**     | Tool/action blocked by policy                   | Write to protected path                    |
+- **Blocked**: Cannot proceed without external input
+- **Ambiguous**: Multiple valid interpretations
+- **Scope Creep**: Task growing beyond bounds
+- **Design Flaw**: Current approach won't work
+- **Risk**: Could cause significant damage
+- **Permission Denied**: Tool/action blocked
 
-## Escalation Channels
-
-### In-Plan Escalation (for executors)
-
-Create `ESCALATION.md` in the plan directory:
-
-```markdown
-# Escalation: [Brief Title]
-
-**Plan**: [plan-name.md]
-**Task**: [1.3 Task Name]
-**Agent**: [executor]
-**Time**: [ISO timestamp]
-
-## Issue
-
-[What went wrong or what's unclear]
-
-## Context
-
-[Relevant findings, what was tried]
-
-## Options (if known)
-
-1. [Option A] - [trade-off]
-2. [Option B] - [trade-off]
-
-## Blocking
-
-- [ ] Task 1.3 - [blocked task]
-- [ ] Task 1.4 - [dependent task]
-
-## Requested Action
-
-[What you need: decision, clarification, permission]
-```
-
-### Direct Escalation (to calling agent)
-
-Include in your output:
+#### Format
 
 ```markdown
 ### Escalation Required
 
-**Trigger**: [Blocked | Ambiguous | Scope Creep | Design Flaw | Risk | Permission]
-**Impact**: [What's blocked]
-**Need**: [Decision | Clarification | Permission | Guidance]
-
+**Trigger**: [type] | **Impact**: [blocked] | **Need**: [type]
 [Details...]
 ```
 
-## Escalation Information Checklist
-
-Always include:
-
-- [ ] What you were trying to do
-- [ ] What went wrong (specific error or confusion)
-- [ ] What you already tried
-- [ ] What options exist (if known)
-- [ ] What's blocked by this issue
-- [ ] What decision or action you need
+Include: What you tried → What went wrong → Options → What's blocked → What you need
 
-## Orchestrator Handling
+#### Handling
 
-When an escalation is received:
+When receiving escalations:
 
-1. **Assess severity**: Can another agent help, or does user need to decide?
-2. **Route appropriately**:
-   - Design issues → architect
-   - Research gaps → researcher
-   - Codebase questions → explorer
-   - True blockers → user
-3. **Resolve or forward**: Either provide the answer or surface to user
-4. **Document resolution**: Update the escalation file with decision
+1. **Check output** for "Escalation Required" sections
+2. **Route appropriately**
+3. **When surfacing**, include: what agent tried, why blocked, options, decision needed
 
-## Anti-Patterns
+#### Anti-Patterns
 
-- **Don't guess**: If you're unsure, escalate. Wrong assumptions cost more than questions.
-- **Don't retry forever**: After 2 attempts, escalate instead of looping.
-- **Don't expand scope**: If the fix requires changes beyond the task, escalate.
-- **Don't ignore risks**: If an action seems dangerous, escalate before proceeding.
+- Guessing (wrong assumptions cost more than questions)
+- Retrying forever (after 2 attempts, escalate)
+- Expanding scope (changes beyond task → escalate)
+- Ignoring risks (dangerous action → escalate first)
diff --git a/src/agent/util/protocol/index.ts b/src/agent/util/protocol/index.ts
index 58878fc..17f9d76 100644
--- a/src/agent/util/protocol/index.ts
+++ b/src/agent/util/protocol/index.ts
@@ -1,11 +1,11 @@
-import ASYNC_DELEGATION from './async-delegation.md';
 import CONTEXT_HANDLING from './context-handling.md';
+import DELEGATION from './delegation.md';
 import ERROR_HANDLING from './error-handling.md';
 import ESCALATION from './escalation.md';
 import PLAN_VERSIONING from './plan-versioning.md';
 
 const PROTOCOLS: Record<string, string> = {
-  'async-delegation': ASYNC_DELEGATION,
+  delegation: DELEGATION,
   'context-handling': CONTEXT_HANDLING,
   'error-handling': ERROR_HANDLING,
   escalation: ESCALATION,
@@ -17,11 +17,16 @@ const PROTOCOLS: Record<string, string> = {
  * Replaces mustache-style {{protocol:name}} with the full protocol content.
  */
 export function expandProtocols(prompt: string): string {
-  return prompt.replace(/\{\{protocol:([a-z-]+)\}\}/g, (_, name) => {
-    const content = PROTOCOLS[name];
-    if (!content) {
-      throw new Error(`Unknown protocol: ${name}`);
-    }
-    return `\n\n---\n${content}\n---\n`;
-  });
+  return prompt
+    .replace(/\{\{protocols:([a-z-]+)\}\}/g, (_, name) => {
+      const content = PROTOCOLS[name];
+      if (!content) {
+        throw new Error(`Unknown protocol: ${name}`);
+      }
+      return `\n\n${content}\n\n`;
+    })
+    .replace(/\{\{protocols\}\}/g, (_) => {
+      const allProtocols = Object.values(PROTOCOLS).join('\n\n');
+      return `\n\n${allProtocols}\n\n`;
+    });
 }
diff --git a/src/agent/util/protocol/plan-versioning.md b/src/agent/util/protocol/plan-versioning.md
index 721fffa..d20ec43 100644
--- a/src/agent/util/protocol/plan-versioning.md
+++ b/src/agent/util/protocol/plan-versioning.md
@@ -1,10 +1,8 @@
-# Plan Versioning Protocol
+### Plan Versioning Protocol
 
-How to safely update plan files when multiple agents may access them.
+Safely update plan files when multiple agents may access them.
 
-## Version Header Format
-
-Every plan file should include a version header:
+#### Version Header
 
 ```markdown
 # Plan: [Feature Name]
@@ -15,98 +13,47 @@ Every plan file should include a version header:
 **Status**: In Progress
 ```
 
-## Version Incrementing
-
-| Change Type        | Version Bump | Example    |
-| ------------------ | ------------ | ---------- |
-| Task status update | +0.1         | 1.0 → 1.1  |
-| Add/remove task    | +0.1         | 1.1 → 1.2  |
-| Phase completion   | +0.1         | 1.2 → 1.3  |
-| Major restructure  | +1.0         | 1.3 → 2.0  |
-| Initial creation   | 1.0          | (new file) |
+#### Version Bumps
 
-## Read-Modify-Write Workflow
+- Task status update: +0.1 (1.0 → 1.1)
+- Add/remove task: +0.1
+- Phase completion: +0.1
+- Major restructure: +1.0 (1.3 → 2.0)
+- Initial creation: 1.0
 
-```
-1. READ: Fetch current plan, note version number
-2. MODIFY: Make your changes in memory
-3. VERIFY: Check that your changes are coherent
-4. WRITE: Save with incremented version and timestamp
-```
+#### Workflow
 
-**Critical**: Always update `Last Updated` and `Last Agent` fields.
+1. **Read**: Fetch plan, note version
+2. **Modify**: Make changes in memory
+3. **Verify**: Check coherence
+4. **Write**: Save with incremented version and timestamp
 
-## Field Protection
+Always update `Last Updated` and `Last Agent`.
 
-### Protected Fields (manual change only)
+#### Field Protection
 
-- `Status`: Draft → In Progress → Complete (only explicit request)
-- `Complexity`: Set at creation, rarely changed
-- `Overview`: Defines scope, change requires re-planning
+**Protected** (manual change only): Status, Complexity, Overview
 
-### Auto-Mergeable Fields (safe to update)
+**Auto-mergeable**: Task checkboxes, Done-when criteria, timestamps, version
 
-- Task status checkboxes
-- `Done when` criteria checkmarks
-- `Last Updated` timestamp
-- `Last Agent` identifier
-- `Version` number
+#### Conflict Handling
 
-## Conflict Detection
+Before writing:
 
-Before writing, check if the plan changed since you read it:
+- Version unchanged → proceed
+- Version changed → re-read, merge, write
+- Status changed (e.g., paused) → stop and escalate
 
-```
-1. If version hasn't changed: Proceed with write
-2. If version changed: Re-read, merge your changes, write
-3. If status changed (e.g., paused): Stop and escalate
-```
+#### Session Handoff
 
-## Merge Strategy
-
-When version conflict detected:
-
-1. Re-read the plan
-2. Identify what changed (likely another task completed)
-3. Apply your changes to the new state
-4. Increment version from the new base
-5. Write with merged content
-
-## Session Handoff
-
-When stopping mid-plan, leave a checkpoint:
+Leave a checkpoint when stopping mid-plan:
 
 ```markdown
 ## Checkpoint
 
 **Session**: [timestamp]
 **Completed**: Tasks 1.1-1.4
-**In Progress**: Task 2.1 (started, 50% done)
-**Notes**: [Any context the next session needs]
+**In Progress**: Task 2.1 (50% done)
+**Notes**: [Context for next session]
 **Blockers**: [If any]
 ```
-
-## Example Plan Header
-
-```markdown
-# Plan: Add User Authentication
-
-**Version**: 2.1
-**Last Updated**: 2024-01-15T16:45:00Z
-**Last Agent**: executor
-**Status**: In Progress
-**Complexity**: Medium
-**Tasks**: 12
-
-## Checkpoint
-
-**Session**: 2024-01-15T16:45:00Z
-**Completed**: Tasks 1.1-1.4, 2.1-2.2
-**In Progress**: Task 2.3 (JWT validation)
-**Notes**: Using jose library per architect recommendation
-**Blockers**: None
-
-## Overview
-
-...
-```
diff --git a/src/command/init-deep/prompt.md b/src/command/init-deep/prompt.md
index aaef2af..c1c51de 100644
--- a/src/command/init-deep/prompt.md
+++ b/src/command/init-deep/prompt.md
@@ -1,6 +1,8 @@
+# init-deep
+
 You are creating AGENTS.md instruction files for a codebase. These files guide AI coding agents to work effectively within this project.
 
-## Your ONE Job
+## Your Job
 
 Analyze the codebase and create a hierarchy of AGENTS.md files:
 
@@ -120,7 +122,7 @@ Create AGENTS.md files following these principles:
 
 ## Anti-Patterns
 
-- ❌ [What NOT to do and why]
+- [What NOT to do and why]
 ```
 
 ### Phase 4: Decide on Domain-Specific Files
@@ -175,12 +177,12 @@ Before finishing, verify each AGENTS.md file:
 
 ## Anti-Patterns
 
-- ❌ Don't write generic programming advice — agents already know how to code
-- ❌ Don't duplicate documentation that exists elsewhere — reference it instead
-- ❌ Don't create AGENTS.md for every directory — only where truly needed
-- ❌ Don't write novels — agents need scannable, actionable instructions
-- ❌ Don't assume the agent knows your project — explain project-specific terms
-- ❌ Don't forget to include what NOT to do — anti-patterns prevent mistakes
+- Don't write generic programming advice — agents already know how to code
+- Don't duplicate documentation that exists elsewhere — reference it instead
+- Don't create AGENTS.md for every directory — only where truly needed
+- Don't write novels — agents need scannable, actionable instructions
+- Don't assume the agent knows your project — explain project-specific terms
+- Don't forget to include what NOT to do — anti-patterns prevent mistakes
 
 ## Rules
 
diff --git a/src/index.ts b/src/index.ts
index 8319e34..028b424 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -11,7 +11,7 @@ import { setupPermissionConfig } from './permission/index.ts';
 import { setupSkillConfig } from './skill/index.ts';
 import { setupTaskHooks, setupTaskTools } from './task/index.ts';
 import type { ElishaConfigContext } from './types.ts';
-import { aggregateHooks } from './util/hooks.ts';
+import { aggregateHooks } from './util/hook.ts';
 
 export const ElishaPlugin: Plugin = async (ctx: PluginInput) => {
   return {
diff --git a/src/instruction/hooks.ts b/src/instruction/hook.ts
similarity index 99%
rename from src/instruction/hooks.ts
rename to src/instruction/hook.ts
index e41c196..9016e21 100644
--- a/src/instruction/hooks.ts
+++ b/src/instruction/hook.ts
@@ -1,7 +1,6 @@
 import type { PluginInput } from '@opencode-ai/plugin';
 import dedent from 'dedent';
 import type { Hooks } from '../types.ts';
-
 import PROMPT from './prompt.md';
 
 export const setupInstructionHooks = (ctx: PluginInput): Hooks => {
diff --git a/src/instruction/index.ts b/src/instruction/index.ts
index a0ac30c..043a104 100644
--- a/src/instruction/index.ts
+++ b/src/instruction/index.ts
@@ -2,4 +2,4 @@
 export { setupInstructionConfig } from './config.ts';
 
 // Re-export hooks setup
-export { setupInstructionHooks } from './hooks.ts';
+export { setupInstructionHooks } from './hook.ts';
diff --git a/src/mcp/context7.ts b/src/mcp/context7.ts
index 3cab6be..8c184e0 100644
--- a/src/mcp/context7.ts
+++ b/src/mcp/context7.ts
@@ -1,4 +1,5 @@
 import defu from 'defu';
+import { log } from '~/util/index.ts';
 import type { ElishaConfigContext } from '../types.ts';
 import type { McpConfig } from './types.ts';
 
@@ -15,8 +16,13 @@ export const getDefaults = (_ctx: ElishaConfigContext): McpConfig => ({
 
 export const setupContext7McpConfig = (ctx: ElishaConfigContext) => {
   if (!process.env.CONTEXT7_API_KEY) {
-    console.warn(
-      '[Elisha] CONTEXT7_API_KEY not set - Context7 will use public rate limits',
+    log(
+      {
+        level: 'warn',
+        message:
+          '[Elisha] CONTEXT7_API_KEY not set - Context7 will use public rate limits',
+      },
+      ctx,
     );
   }
   ctx.config.mcp ??= {};
diff --git a/src/mcp/exa.ts b/src/mcp/exa.ts
index f1334e5..5029985 100644
--- a/src/mcp/exa.ts
+++ b/src/mcp/exa.ts
@@ -1,4 +1,5 @@
 import defu from 'defu';
+import { log } from '~/util/index.ts';
 import type { ElishaConfigContext } from '../types.ts';
 import type { McpConfig } from './types.ts';
 
@@ -15,8 +16,13 @@ export const getDefaults = (_ctx: ElishaConfigContext): McpConfig => ({
 
 export const setupExaMcpConfig = (ctx: ElishaConfigContext) => {
   if (!process.env.EXA_API_KEY) {
-    console.warn(
-      '[Elisha] EXA_API_KEY not set - Exa search will use public rate limits',
+    log(
+      {
+        level: 'warn',
+        message:
+          '[Elisha] EXA_API_KEY not set - Exa search will use public rate limits',
+      },
+      ctx,
     );
   }
   ctx.config.mcp ??= {};
diff --git a/src/mcp/hooks.ts b/src/mcp/hook.ts
similarity index 72%
rename from src/mcp/hooks.ts
rename to src/mcp/hook.ts
index abc2e1e..789abbd 100644
--- a/src/mcp/hooks.ts
+++ b/src/mcp/hook.ts
@@ -1,19 +1,28 @@
 import type { PluginInput } from '@opencode-ai/plugin';
 import dedent from 'dedent';
+import { log } from '~/util/index.ts';
 import type { Hooks } from '../types.ts';
-
-import PROMPT from './memory-prompt.md';
+import PROMPT from './memory-hook-prompt.md';
 
 /**
  * Validates and sanitizes memory content to prevent poisoning attacks.
  * Wraps content in <untrusted-memory> tags with warnings.
  */
-export const validateMemoryContent = (content: string): string => {
+export const validateMemoryContent = (
+  content: string,
+  ctx: PluginInput,
+): string => {
   let sanitized = content;
 
   // Detect HTML comments that might contain hidden instructions
   if (/<!--[\s\S]*?-->/.test(sanitized)) {
-    console.warn('[Elisha] Suspicious HTML comment detected in memory content');
+    log(
+      {
+        level: 'warn',
+        message: '[Elisha] Suspicious HTML comment detected in memory content',
+      },
+      ctx,
+    );
     sanitized = sanitized.replace(/<!--[\s\S]*?-->/g, '');
   }
 
@@ -28,8 +37,12 @@ export const validateMemoryContent = (content: string): string => {
 
   for (const pattern of suspiciousPatterns) {
     if (pattern.test(sanitized)) {
-      console.warn(
-        `[Elisha] Suspicious imperative pattern detected: ${pattern}`,
+      log(
+        {
+          level: 'warn',
+          message: `[Elisha] Suspicious imperative pattern detected: ${pattern}`,
+        },
+        ctx,
       );
     }
   }
@@ -45,29 +58,8 @@ export const validateMemoryContent = (content: string): string => {
   `;
 };
 
-const SESSION_TTL_MS = 24 * 60 * 60 * 1000;
-const MAX_SESSIONS = 1000;
-
 export const setupMcpHooks = (ctx: PluginInput): Hooks => {
-  const injectedSessions = new Map<string, number>();
-
-  const cleanupSessions = () => {
-    const now = Date.now();
-    for (const [id, timestamp] of injectedSessions.entries()) {
-      if (now - timestamp > SESSION_TTL_MS) {
-        injectedSessions.delete(id);
-      }
-    }
-    if (injectedSessions.size > MAX_SESSIONS) {
-      const keysToRemove = Array.from(injectedSessions.keys()).slice(
-        0,
-        injectedSessions.size - MAX_SESSIONS,
-      );
-      for (const key of keysToRemove) {
-        injectedSessions.delete(key);
-      }
-    }
-  };
+  const injectedSessions = new Set<string>();
 
   return {
     'chat.message': async (_input, output) => {
@@ -92,13 +84,11 @@ export const setupMcpHooks = (ctx: PluginInput): Hooks => {
         );
       });
       if (hasMemoryCtx) {
-        cleanupSessions();
-        injectedSessions.set(sessionId, Date.now());
+        injectedSessions.add(sessionId);
         return;
       }
 
-      cleanupSessions();
-      injectedSessions.set(sessionId, Date.now());
+      injectedSessions.add(sessionId);
       await ctx.client.session.prompt({
         path: { id: sessionId },
         body: {
@@ -110,7 +100,7 @@ export const setupMcpHooks = (ctx: PluginInput): Hooks => {
               type: 'text',
               text: dedent`
               <memory-context>
-                ${validateMemoryContent(PROMPT)}
+                ${validateMemoryContent(PROMPT, ctx)}
               </memory-context>`,
               synthetic: true,
             },
@@ -120,7 +110,7 @@ export const setupMcpHooks = (ctx: PluginInput): Hooks => {
     },
     'tool.execute.after': async (input, output) => {
       if (input.tool === 'openmemory_openmemory_query') {
-        output.output = validateMemoryContent(output.output);
+        output.output = validateMemoryContent(output.output, ctx);
       }
     },
     event: async ({ event }) => {
@@ -141,8 +131,7 @@ export const setupMcpHooks = (ctx: PluginInput): Hooks => {
             return {};
           });
 
-        cleanupSessions();
-        injectedSessions.set(sessionId, Date.now());
+        injectedSessions.add(sessionId);
         await ctx.client.session.prompt({
           path: { id: sessionId },
           body: {
@@ -154,7 +143,7 @@ export const setupMcpHooks = (ctx: PluginInput): Hooks => {
                 type: 'text',
                 text: dedent`
                 <memory-context>
-                  ${validateMemoryContent(PROMPT)}
+                  ${validateMemoryContent(PROMPT, ctx)}
                 </memory-context>`,
                 synthetic: true,
               },
diff --git a/src/mcp/index.ts b/src/mcp/index.ts
index 485c2c0..8f0c1b5 100644
--- a/src/mcp/index.ts
+++ b/src/mcp/index.ts
@@ -7,7 +7,7 @@ export { MCP_CONTEXT7_ID } from './context7.ts';
 export { MCP_EXA_ID } from './exa.ts';
 export { MCP_GREP_APP_ID } from './grep-app.ts';
 // Re-export hooks setup
-export { setupMcpHooks } from './hooks.ts';
+export { setupMcpHooks } from './hook.ts';
 export { MCP_OPENMEMORY_ID } from './openmemory.ts';
 // Re-export types
 export * from './types.ts';
diff --git a/src/mcp/memory-prompt.md b/src/mcp/memory-hook-prompt.md
similarity index 100%
rename from src/mcp/memory-prompt.md
rename to src/mcp/memory-hook-prompt.md
diff --git a/src/permission/defaults.ts b/src/permission/defaults.ts
index de10fbb..1bd646b 100644
--- a/src/permission/defaults.ts
+++ b/src/permission/defaults.ts
@@ -5,7 +5,7 @@ import { MCP_CONTEXT7_ID } from '../mcp/context7.ts';
 import { MCP_EXA_ID } from '../mcp/exa.ts';
 import { MCP_GREP_APP_ID } from '../mcp/grep-app.ts';
 import { MCP_OPENMEMORY_ID } from '../mcp/openmemory.ts';
-import { TOOL_TASK_ID } from '../task/tools.ts';
+import { TOOL_TASK_ID } from '../task/tool.ts';
 import type { ElishaConfigContext } from '../types.ts';
 
 export const getDefaultPermissions = (
@@ -51,7 +51,7 @@ export const getDefaultPermissions = (
   }
 
   if (ctx.config.mcp?.[MCP_CHROME_DEVTOOLS_ID]?.enabled ?? true) {
-    config[`${MCP_CHROME_DEVTOOLS_ID}*`] = 'deny';
+    config[`${MCP_CHROME_DEVTOOLS_ID}*`] = 'deny'; // Selectively allow in agents
   }
 
   return config;
diff --git a/src/task/hook.ts b/src/task/hook.ts
new file mode 100644
index 0000000..bc9f776
--- /dev/null
+++ b/src/task/hook.ts
@@ -0,0 +1,130 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+import dedent from 'dedent';
+import { getSessionModelAndAgent } from '~/agent/util/index.ts';
+import { log } from '~/util/index.ts';
+import type { Hooks } from '../types.ts';
+import PROMPT from './prompt.md';
+import { ASYNC_TASK_PREFIX } from './tool.ts';
+import { getTaskList, isTaskComplete } from './util.ts';
+
+export const setupTaskHooks = (ctx: PluginInput): Hooks => {
+  const injectedSessions = new Set<string>();
+
+  return {
+    event: async ({ event }) => {
+      // Notify parent session when task completes
+      if (event.type === 'session.idle') {
+        const sessionID = event.properties.sessionID;
+        const completed = await isTaskComplete(sessionID, ctx);
+        if (completed) {
+          const { data: session } = await ctx.client.session.get({
+            path: { id: sessionID },
+            query: { directory: ctx.directory },
+          });
+
+          const title = session?.title;
+          const parentID = session?.parentID;
+          if (title?.startsWith(ASYNC_TASK_PREFIX) && parentID) {
+            const { model, agent: parentAgent } = await getSessionModelAndAgent(
+              parentID,
+              ctx,
+            );
+
+            let taskAgent = 'unknown';
+            try {
+              const { agent } = await getSessionModelAndAgent(sessionID, ctx);
+              taskAgent = agent || 'unknown';
+            } catch (error) {
+              log(
+                {
+                  level: 'error',
+                  message: `Failed to get agent name for task(${sessionID}): ${
+                    error instanceof Error ? error.message : 'Unknown error'
+                  }`,
+                },
+                ctx,
+              );
+            }
+
+            // Notify parent that task completed (use elisha_task_output to get result)
+            const notification = JSON.stringify({
+              status: 'completed',
+              task_id: sessionID,
+              agent: taskAgent,
+              title: session?.title || 'Untitled task',
+              message:
+                'Task completed. Use elisha_task_output to get the result.',
+            });
+
+            try {
+              await ctx.client.session.prompt({
+                path: { id: parentID },
+                body: {
+                  agent: parentAgent,
+                  model,
+                  parts: [
+                    {
+                      type: 'text',
+                      text: notification,
+                      synthetic: true,
+                    },
+                  ],
+                },
+                query: { directory: ctx.directory },
+              });
+            } catch (error) {
+              log(
+                {
+                  level: 'error',
+                  message: `Failed to notify parent session(${parentID}) of task(${sessionID}) completion: ${
+                    error instanceof Error ? error.message : 'Unknown error'
+                  }`,
+                },
+                ctx,
+              );
+            }
+          }
+        }
+      }
+
+      // Inject task context when session is compacted
+      if (event.type === 'session.compacted') {
+        const sessionID = event.properties.sessionID;
+
+        // Get tasks for this session
+        const taskList = await getTaskList(sessionID, ctx);
+        if (taskList) {
+          // Get model/agent from recent messages
+          const { model, agent } = await getSessionModelAndAgent(
+            sessionID,
+            ctx,
+          );
+
+          injectedSessions.add(sessionID);
+
+          await ctx.client.session.prompt({
+            path: { id: sessionID },
+            body: {
+              noReply: true,
+              model,
+              agent,
+              parts: [
+                {
+                  type: 'text',
+                  text: dedent`
+                  <task-context>
+                  ${PROMPT}
+
+                  ${taskList}
+                  </task-context>
+                `,
+                  synthetic: true,
+                },
+              ],
+            },
+          });
+        }
+      }
+    },
+  };
+};
diff --git a/src/task/hooks.ts b/src/task/hooks.ts
deleted file mode 100644
index 3c7df60..0000000
--- a/src/task/hooks.ts
+++ /dev/null
@@ -1,102 +0,0 @@
-import type { PluginInput } from '@opencode-ai/plugin';
-import dedent from 'dedent';
-import type { Hooks } from '../types.ts';
-
-import PROMPT from './prompt.md';
-
-const SESSION_TTL_MS = 24 * 60 * 60 * 1000;
-const MAX_SESSIONS = 1000;
-
-export const setupTaskHooks = (ctx: PluginInput): Hooks => {
-  const injectedSessions = new Map<string, number>();
-
-  const cleanupSessions = () => {
-    const now = Date.now();
-    for (const [id, timestamp] of injectedSessions.entries()) {
-      if (now - timestamp > SESSION_TTL_MS) {
-        injectedSessions.delete(id);
-      }
-    }
-    if (injectedSessions.size > MAX_SESSIONS) {
-      const keysToRemove = Array.from(injectedSessions.keys()).slice(
-        0,
-        injectedSessions.size - MAX_SESSIONS,
-      );
-      for (const key of keysToRemove) {
-        injectedSessions.delete(key);
-      }
-    }
-  };
-
-  const getTaskList = async (sessionId: string): Promise<string | null> => {
-    // Get child sessions (tasks) for this session
-    const { data: children } = await ctx.client.session.children({
-      path: { id: sessionId },
-    });
-
-    if (!children || children.length === 0) {
-      return null;
-    }
-
-    // Format task IDs as a list
-    const taskList = children
-      .map((child) => `- \`${child.id}\` - ${child.title || 'Untitled task'}`)
-      .join('\n');
-
-    return taskList;
-  };
-
-  return {
-    event: async ({ event }) => {
-      if (event.type === 'session.compacted') {
-        const sessionId = event.properties.sessionID;
-
-        // Get tasks for this session
-        const taskList = await getTaskList(sessionId);
-        if (!taskList) {
-          return; // No tasks to inject
-        }
-
-        // Get model/agent from recent messages
-        const { model, agent } = await ctx.client.session
-          .messages({
-            path: { id: sessionId },
-            query: { limit: 50 },
-          })
-          .then(({ data }) => {
-            for (const msg of data || []) {
-              if ('model' in msg.info && msg.info.model) {
-                return { model: msg.info.model, agent: msg.info.agent };
-              }
-            }
-            return { model: undefined, agent: undefined };
-          });
-
-        cleanupSessions();
-        injectedSessions.set(sessionId, Date.now());
-
-        await ctx.client.session.prompt({
-          path: { id: sessionId },
-          body: {
-            noReply: true,
-            model,
-            agent,
-            parts: [
-              {
-                type: 'text',
-                text: dedent`
-                  <task-context>
-                  ${PROMPT}
-
-                  ${taskList}
-                  </task-context>
-                `,
-                synthetic: true,
-              },
-            ],
-          },
-        });
-      }
-    },
-  };
-};
diff --git a/src/task/index.ts b/src/task/index.ts
index d620b39..4dbbd67 100644
--- a/src/task/index.ts
+++ b/src/task/index.ts
@@ -1,4 +1,4 @@
 // Re-export hooks setup
-export { setupTaskHooks } from './hooks.ts';
+export { setupTaskHooks } from './hook.ts';
 // Re-export tools setup
-export { getActiveAgents, setupTaskTools, TOOL_TASK_ID } from './tools.ts';
+export { setupTaskTools, TOOL_TASK_ID } from './tool.ts';
diff --git a/src/task/tools.ts b/src/task/tool.ts
similarity index 61%
rename from src/task/tools.ts
rename to src/task/tool.ts
index b614faa..2151622 100644
--- a/src/task/tools.ts
+++ b/src/task/tool.ts
@@ -1,145 +1,15 @@
 import { type PluginInput, tool } from '@opencode-ai/plugin';
-import Bun from 'bun';
+import { getActiveAgents } from '~/agent/util/index.ts';
+import { log } from '~/util/index.ts';
 import type { Tools } from '../types.ts';
+import type { TaskResult } from './types.ts';
+import { fetchTaskText, isTaskComplete, waitForTask } from './util.ts';
 
 const z = tool.schema;
 
 export const TOOL_TASK_ID = 'elisha_task';
 
-const POLL_INTERVAL_MS = 500;
-const TIMEOUT_MS = 20 * 60 * 1000; // 20 minutes
-
-const MAX_CONCURRENT_TASKS = 5;
-const activeTasks = new Set<string>();
-
-export type TaskResult =
-  | {
-      status: 'completed';
-      taskId: string;
-      agent: string;
-      title: string;
-      result: string;
-    }
-  | {
-      status: 'failed';
-      taskId?: string;
-      error: string;
-      code:
-        | 'AGENT_NOT_FOUND'
-        | 'SESSION_ERROR'
-        | 'TIMEOUT'
-        | 'CANCELLED'
-        | 'CONCURRENCY_LIMIT';
-    }
-  | { status: 'running'; taskId: string; title: string }
-  | { status: 'cancelled'; taskId: string };
-
-export const getActiveAgents = async (ctx: PluginInput) => {
-  return await ctx.client.app
-    .agents({
-      query: { directory: ctx.directory },
-    })
-    .then((res) => res.data || []);
-};
-
-const isTaskComplete = async (
-  id: string,
-  ctx: PluginInput,
-): Promise<boolean> => {
-  try {
-    const [sessionStatus, sessionMessages] = await Promise.all([
-      ctx.client.session
-        .status({
-          query: { directory: ctx.directory },
-        })
-        .then((r) => r.data?.[id]),
-      ctx.client.session
-        .messages({
-          path: { id },
-          query: { limit: 1 },
-        })
-        .then((r) => r.data),
-    ]);
-
-    // Session not found in status map - may have completed and been cleaned up
-    if (!sessionStatus) {
-      // Confirm by checking if session has messages
-      const { data: messages } = await ctx.client.session.messages({
-        path: { id },
-        query: { limit: 1 },
-      });
-      // If session has messages and no status, likely completed
-      return !!(messages && messages.length > 0);
-    }
-
-    // No messages yet, session is still busy
-    if (!sessionMessages || sessionMessages.length === 0) {
-      return false;
-    }
-
-    // Session is idle (completed)
-    if (sessionStatus.type === 'idle') {
-      return true;
-    }
-
-    return false;
-  } catch {
-    // On transient API errors, return false to continue polling
-    return false;
-  }
-};
-
-const MAX_POLL_INTERVAL_MS = 5000;
-const BACKOFF_MULTIPLIER = 1.5;
-
-const waitForTask = async (
-  id: string,
-  timeoutMs = TIMEOUT_MS,
-  ctx: PluginInput,
-): Promise<boolean> => {
-  const effectiveTimeout = Math.max(timeoutMs, 1000);
-  const startTime = Date.now();
-  let pollInterval = POLL_INTERVAL_MS;
-  while (Date.now() - startTime < effectiveTimeout) {
-    const complete = await isTaskComplete(id, ctx);
-    if (complete) {
-      return true;
-    }
-    await Bun.sleep(pollInterval);
-    pollInterval = Math.min(
-      pollInterval * BACKOFF_MULTIPLIER,
-      MAX_POLL_INTERVAL_MS,
-    );
-  }
-
-  return false;
-};
-
-const fetchTaskText = async (id: string, ctx: PluginInput): Promise<string> => {
-  const { data: messages } = await ctx.client.session.messages({
-    path: { id: id },
-    query: { limit: 200 },
-  });
-  if (!messages) {
-    throw new Error('No messages were found.');
-  }
-
-  // Find the last assistant message
-  const lastAssistantMessage = [...messages]
-    .reverse()
-    .find((msg) => msg.info.role === 'assistant');
-  if (!lastAssistantMessage) {
-    throw new Error('No assistant response was found.');
-  }
-
-  // Extract text content from the message parts
-  return (
-    lastAssistantMessage.parts
-      .filter((part) => part.type === 'text')
-      .map((part) => part.text)
-      .join('\n') || '(No text content in response)'
-  );
-};
+export const ASYNC_TASK_PREFIX = '[async]';
 
 export const setupTaskTools = async (ctx: PluginInput): Promise<Tools> => {
   return {
@@ -159,14 +29,6 @@ export const setupTaskTools = async (ctx: PluginInput): Promise<Tools> => {
           ),
       },
       execute: async (args, context) => {
-        if (activeTasks.size >= MAX_CONCURRENT_TASKS) {
-          return JSON.stringify({
-            status: 'failed',
-            error: `Maximum concurrent tasks reached (${MAX_CONCURRENT_TASKS}). Please wait for other tasks to complete.`,
-            code: 'CONCURRENCY_LIMIT',
-          } satisfies TaskResult);
-        }
-
         const activeAgents = await getActiveAgents(ctx);
         if (!activeAgents?.find((agent) => agent.name === args.agent)) {
           return JSON.stringify({
@@ -181,7 +43,9 @@ export const setupTaskTools = async (ctx: PluginInput): Promise<Tools> => {
           const { data } = await ctx.client.session.create({
             body: {
               parentID: context.sessionID,
-              title: `Task: ${args.title}`,
+              title: args.async
+                ? `${ASYNC_TASK_PREFIX} Task: ${args.title}`
+                : `Task: ${args.title}`,
             },
             query: { directory: ctx.directory },
           });
@@ -212,19 +76,21 @@ export const setupTaskTools = async (ctx: PluginInput): Promise<Tools> => {
           query: { directory: ctx.directory },
         });
 
-        activeTasks.add(session.id);
-
         if (args.async) {
-          promise
-            .catch((error) => {
-              console.error(`Task(${session.id}) failed to start: ${error}`);
-            })
-            .finally(() => {
-              activeTasks.delete(session.id);
-            });
+          promise.catch((error) => {
+            log(
+              {
+                level: 'error',
+                message: `Task(${session.id}) failed to start: ${
+                  error instanceof Error ? error.message : 'Unknown error'
+                }`,
+              },
+              ctx,
+            );
+          });
           return JSON.stringify({
             status: 'running',
-            taskId: session.id,
+            task_id: session.id,
             title: args.title,
           } satisfies TaskResult);
         }
@@ -234,7 +100,7 @@ export const setupTaskTools = async (ctx: PluginInput): Promise<Tools> => {
           const result = await fetchTaskText(session.id, ctx);
           return JSON.stringify({
             status: 'completed',
-            taskId: session.id,
+            task_id: session.id,
             agent: args.agent,
             title: args.title,
             result,
@@ -242,12 +108,10 @@ export const setupTaskTools = async (ctx: PluginInput): Promise<Tools> => {
         } catch (error) {
           return JSON.stringify({
             status: 'failed',
-            taskId: session.id,
+            task_id: session.id,
             error: error instanceof Error ? error.message : 'Unknown error',
             code: 'SESSION_ERROR',
           } satisfies TaskResult);
-        } finally {
-          activeTasks.delete(session.id);
         }
       },
     }),
@@ -278,8 +142,8 @@ export const setupTaskTools = async (ctx: PluginInput): Promise<Tools> => {
         if (!task) {
           return JSON.stringify({
             status: 'failed',
-            taskId: args.task_id,
-            error: `Task(${args.task_id}) not found.`,
+            task_id: args.task_id,
+            error: `Task not found.`,
             code: 'SESSION_ERROR',
           } satisfies TaskResult);
         }
@@ -305,7 +169,7 @@ export const setupTaskTools = async (ctx: PluginInput): Promise<Tools> => {
             const agent = await getAgentName();
             return JSON.stringify({
               status: 'completed',
-              taskId: task.id,
+              task_id: task.id,
               agent,
               title: task.title,
               result,
@@ -313,7 +177,7 @@ export const setupTaskTools = async (ctx: PluginInput): Promise<Tools> => {
           } catch (error) {
             return JSON.stringify({
               status: 'failed',
-              taskId: task.id,
+              task_id: task.id,
               error: error instanceof Error ? error.message : 'Unknown error',
               code: 'SESSION_ERROR',
             } satisfies TaskResult);
@@ -325,8 +189,9 @@ export const setupTaskTools = async (ctx: PluginInput): Promise<Tools> => {
           if (!waitResult) {
             return JSON.stringify({
               status: 'failed',
-              taskId: task.id,
-              error: 'Reached timeout waiting for task completion.',
+              task_id: task.id,
+              error:
+                'Reached timeout waiting for task completion. Try again later or add a longer timeout.',
               code: 'TIMEOUT',
             } satisfies TaskResult);
           }
@@ -336,7 +201,7 @@ export const setupTaskTools = async (ctx: PluginInput): Promise<Tools> => {
             const agent = await getAgentName();
             return JSON.stringify({
               status: 'completed',
-              taskId: task.id,
+              task_id: task.id,
               agent,
               title: task.title,
               result,
@@ -344,7 +209,7 @@ export const setupTaskTools = async (ctx: PluginInput): Promise<Tools> => {
           } catch (error) {
             return JSON.stringify({
               status: 'failed',
-              taskId: task.id,
+              task_id: task.id,
               error: error instanceof Error ? error.message : 'Unknown error',
               code: 'SESSION_ERROR',
             } satisfies TaskResult);
@@ -353,7 +218,7 @@ export const setupTaskTools = async (ctx: PluginInput): Promise<Tools> => {
 
         return JSON.stringify({
           status: 'running',
-          taskId: task.id,
+          task_id: task.id,
           title: task.title,
         } satisfies TaskResult);
       },
@@ -373,8 +238,8 @@ export const setupTaskTools = async (ctx: PluginInput): Promise<Tools> => {
         if (!task) {
           return JSON.stringify({
             status: 'failed',
-            taskId: args.task_id,
-            error: `Task(${args.task_id}) not found.`,
+            task_id: args.task_id,
+            error: `Task not found.`,
             code: 'SESSION_ERROR',
           } satisfies TaskResult);
         }
@@ -383,8 +248,8 @@ export const setupTaskTools = async (ctx: PluginInput): Promise<Tools> => {
         if (completed) {
           return JSON.stringify({
             status: 'failed',
-            taskId: task.id,
-            error: `Task(${args.task_id}) already completed.`,
+            task_id: task.id,
+            error: `Task already completed.`,
             code: 'SESSION_ERROR',
           } satisfies TaskResult);
         }
@@ -399,15 +264,15 @@ export const setupTaskTools = async (ctx: PluginInput): Promise<Tools> => {
           if (nowCompleted) {
             return JSON.stringify({
               status: 'failed',
-              taskId: task.id,
-              error: `Task(${args.task_id}) completed before cancellation.`,
+              task_id: task.id,
+              error: `Task completed before cancellation.`,
               code: 'SESSION_ERROR',
             } satisfies TaskResult);
           }
           return JSON.stringify({
             status: 'failed',
-            taskId: task.id,
-            error: `Failed to cancel Task(${args.task_id}): ${
+            task_id: task.id,
+            error: `Failed to cancel task: ${
               error instanceof Error ? error.message : 'Unknown error'
             }`,
             code: 'SESSION_ERROR',
@@ -416,7 +281,7 @@ export const setupTaskTools = async (ctx: PluginInput): Promise<Tools> => {
 
         return JSON.stringify({
           status: 'cancelled',
-          taskId: task.id,
+          task_id: task.id,
         } satisfies TaskResult);
       },
     }),
diff --git a/src/task/types.ts b/src/task/types.ts
new file mode 100644
index 0000000..6df5524
--- /dev/null
+++ b/src/task/types.ts
@@ -0,0 +1,16 @@
+export type TaskResult =
+  | {
+      status: 'completed';
+      task_id: string;
+      agent: string;
+      title: string;
+      result: string;
+    }
+  | {
+      status: 'failed';
+      task_id?: string;
+      error: string;
+      code: 'AGENT_NOT_FOUND' | 'SESSION_ERROR' | 'TIMEOUT' | 'CANCELLED';
+    }
+  | { status: 'running'; task_id: string; title: string }
+  | { status: 'cancelled'; task_id: string };
diff --git a/src/task/util.ts b/src/task/util.ts
new file mode 100644
index 0000000..ce68751
--- /dev/null
+++ b/src/task/util.ts
@@ -0,0 +1,125 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { Session } from '@opencode-ai/sdk';
+
+const MAX_POLL_INTERVAL_MS = 5000;
+const BACKOFF_MULTIPLIER = 1.5;
+const POLL_INTERVAL_MS = 500;
+const TIMEOUT_MS = 20 * 60 * 1000; // 20 minutes
+
+export const getTasks = async (
+  sessionId: string,
+  ctx: PluginInput,
+): Promise<Session[]> => {
+  // Get child sessions (tasks) for this session
+  const { data: children } = await ctx.client.session.children({
+    path: { id: sessionId },
+    query: { directory: ctx.directory },
+  });
+
+  return children || [];
+};
+
+export const getTaskList = async (
+  sessionId: string,
+  ctx: PluginInput,
+): Promise<string | null> => {
+  const children = await getTasks(sessionId, ctx);
+  // Format task IDs as a list
+  const taskList = children
+    .map((child) => `- \`${child.id}\` - ${child.title || 'Untitled task'}`)
+    .join('\n');
+
+  return taskList;
+};
+
+export const isTaskComplete = async (
+  id: string,
+  ctx: PluginInput,
+): Promise<boolean> => {
+  try {
+    const [sessionStatus, sessionMessages] = await Promise.all([
+      ctx.client.session
+        .status({
+          query: { directory: ctx.directory },
+        })
+        .then((r) => r.data?.[id]),
+      ctx.client.session
+        .messages({
+          path: { id },
+          query: { directory: ctx.directory, limit: 1 },
+        })
+        .then((r) => r.data),
+    ]);
+
+    // Session not found in status map - may have completed and been cleaned up
+    if (!sessionStatus) {
+      // Confirm by checking if session has messages
+      const { data: messages } = await ctx.client.session.messages({
+        path: { id },
+        query: { limit: 1 },
+      });
+      // If session has messages and no status, likely completed
+      return !!(messages && messages.length > 0);
+    }
+
+    // No messages yet, session is still busy
+    if (!sessionMessages || sessionMessages.length === 0) {
+      return false;
+    }
+
+    // Session is idle (completed)
+    if (sessionStatus.type === 'idle') {
+      return true;
+    }
+
+    return false;
+  } catch {
+    // On transient API errors, return false to continue polling
+    return false;
+  }
+};
+
+export const waitForTask = async (
+  id: string,
+  timeoutMs = TIMEOUT_MS,
+  ctx: PluginInput,
+): Promise<boolean> => {
+  const effectiveTimeout = Math.max(timeoutMs, 1000);
+  const startTime = Date.now();
+  let pollInterval = POLL_INTERVAL_MS;
+  while (Date.now() - startTime < effectiveTimeout) {
+    const complete = await isTaskComplete(id, ctx);
+    if (complete) {
+      return true;
+    }
+    await Bun.sleep(pollInterval);
+    pollInterval = Math.min(
+      pollInterval * BACKOFF_MULTIPLIER,
+      MAX_POLL_INTERVAL_MS,
+    );
+  }
+
+  return false;
+};
+
+export const fetchTaskText = async (
+  id: string,
+  ctx: PluginInput,
+): Promise<string> => {
+  const { data: messages } = await ctx.client.session.messages({
+    path: { id: id },
+    query: { limit: 200 },
+  });
+  if (!messages) {
+    throw new Error('No messages were found.');
+  }
+
+  // Extract text content from the message parts
+  return (
+    messages
+      .flatMap((message) => message.parts)
+      .filter((part) => part.type === 'text')
+      .map((part) => part.text)
+      .join('\n') || '(No text content in response)'
+  );
+};
diff --git a/src/util/hooks.ts b/src/util/hook.ts
similarity index 100%
rename from src/util/hooks.ts
rename to src/util/hook.ts
diff --git a/src/util/index.ts b/src/util/index.ts
index 0fbac1d..5255b51 100644
--- a/src/util/index.ts
+++ b/src/util/index.ts
@@ -5,7 +5,7 @@ import type { LogLevel } from '@opencode-ai/sdk/v2';
 
 // Re-export from submodules
 export * from '../types.ts';
-export * from './hooks.ts';
+export * from './hook.ts';
 
 export const getCacheDir = () => {
   if (process.platform === 'win32') {