opencode-raven 2.0.0 → 2.0.1

package/README.md

@@ -4,25 +4,25 @@
 <tr>
 <td><img src="Raven.png" alt="Raven" width="768" /></td>
 <td>
-<strong>Hard tool/MCP rerouter for <a href="https://opencode.ai">opencode</a></strong><br/>
-Blocks configured tools and MCPs for non-Raven agents, then routes those requests through a focused Raven agent to reduce context flooding.
+<strong>Hard tool/MCP rerouter for <a href="https://opencode.ai">opencode</a></strong><br/>
+Blocks configured tools and MCPs for non-Raven agents, then routes those requests through a focused Raven agent to avoid flooding and wasting your main model's context, mostly from searches, docs, web pages, GitHub examples, and verbose MCP calls.
 </td>
 </tr>
 </table>
 
 ## Why?
 
-Tool-heavy work floods context. Search, docs, web, GitHub examples, and verbose MCP calls can dump raw results into your expensive main model. Raven is a hard blocker-rerouter: configured tools fail closed for non-Raven agents and must be delegated through `raven_seek`, where a focused Raven agent performs the work and returns a compact answer.
-
-Raven fixes three problems:
-
-1. **Context flooding** — Keep noisy tool results out of the main session. Raven summarizes tool/MCP output before returning it.
-2. **Cost** — Use a cheaper model like `opencode/deepseek-v4-flash-free` for tool-heavy work while saving your main model's context for decisions and edits.
-3. **Enforcement** — This is not soft nudging. Raven blocks configured tools/MCP prefixes for non-Raven agents and gives them the exact `raven_seek` retry path.
-
-Raven defaults to search/fetch/docs/GitHub routing, but it works with any MCP whose opencode tool names share a prefix.
-
-Important limitation: opencode still loads enabled MCP tool schemas into the main session. Raven saves context from tool calls and raw results, but it cannot hide initial MCP schemas from the main model until opencode supports agent-scoped MCP visibility.
+Tool-heavy work floods context. Search, docs, web, GitHub examples, and verbose MCP calls can dump raw results into your expensive main model. Raven is a hard blocker-rerouter: configured tools fail closed for non-Raven agents and must be delegated through `raven_seek`, where a focused Raven agent performs the work and returns a compact answer.
+
+Raven fixes three problems:
+
+1. **Context flooding** — Keep noisy tool results out of the main session. Raven summarizes tool/MCP output before returning it.
+2. **Cost** — Use a cheaper model like `opencode/deepseek-v4-flash-free` for tool-heavy work while saving your main model's context for decisions and edits.
+3. **Enforcement** — This is not soft nudging. Raven blocks configured tools/MCP prefixes for non-Raven agents and gives them the exact `raven_seek` retry path.
+
+Raven defaults to search/fetch/docs/GitHub routing, but it works with any MCP whose opencode tool names share a prefix.
+
+Important limitation: opencode still loads enabled MCP tool schemas into the main session. Raven saves context from tool calls and raw results, but it cannot hide initial MCP schemas from the main model until opencode supports agent-scoped MCP visibility.
 
 ## Install
 
@@ -46,19 +46,21 @@ Restart opencode.
 
 | Command | Action |
 |---------|--------|
-| `/raven` | Show status — enabled/disabled, version, update availability, model, routing, reasoning effort, timeout (no args) |
-| `/raven on` | Enable hard tool/MCP routing (default) |
-| `/raven off` | Disable routing — all agents can use routed tools directly |
-| `/raven route` | Show routed tools and MCP server prefixes |
-| `/raven route tool add <name>` | Route a specific tool through Raven |
+| `/raven` | Show status — enabled/disabled, version, update availability, model, routing, reasoning effort, timeout (no args) |
+| `/raven on` | Enable hard tool/MCP routing (default) |
+| `/raven off` | Disable routing — all agents can use routed tools directly |
+| `/raven route` | Show routed tools and MCP server prefixes |
+| `/raven route tool add <name>` | Route a specific tool through Raven |
 | `/raven route tool remove <name>` | Stop routing a specific tool |
 | `/raven route mcp add <server>` | Route every tool whose name starts with `<server>_` through Raven |
 | `/raven route mcp remove <server>` | Stop routing an MCP server prefix |
+| `/raven route keyword add <keyword>` | Route any tool whose name contains `<keyword>` |
+| `/raven route keyword remove <keyword>` | Stop routing a tool-name keyword |
 | `/raven update` | Check npm for a newer Raven, clear opencode's plugin cache if needed, then restart opencode |
 | `/raven model <name>` | Change Raven's model (requires restart) |
 | `/raven effort <value>` | Change Raven's reasoning effort (requires restart) |
 | `/raven timeout <seconds>` | Change raven_seek timeout (min 10s, takes effect immediately) |
-| `/raven stats` | Show context saved (session + all-time, bytes + tokens) |
+| `/raven stats` | Show estimated context saved (session + all-time, bytes + tokens) |
 
 Config persists across restarts in `~/.config/opencode/raven-config.json` (global, shared across all projects). Auto-created on first run.
 
@@ -98,7 +100,7 @@ You can call Raven directly with `@Raven` in any opencode chat. The Raven agent
 
 ## raven_seek
 
-When configured tools/MCPs are blocked, agents use **`raven_seek`** — a unified delegation tool that sends the request to Raven. It handles routed MCP requests, local codebase search, filesystem discovery, specific URL/page reads, web/docs research, GitHub examples, and command-output/system inspection. Output includes elapsed time and tokens processed.
+When configured tools/MCPs are blocked, agents use **`raven_seek`** — a unified delegation tool that sends the request to Raven. It handles routed MCP requests, local codebase search, filesystem discovery, specific URL/page reads, web/docs research, GitHub examples, and command-output/system inspection. Output includes elapsed time and tokens processed.
 
 ```
 raven_seek(query: "how to use useEffect cleanup")
@@ -106,42 +108,44 @@ raven_seek(query: "Fetch/read https://example.com and summarize install steps")
 raven_seek(query: "Check whether archivemount/libarchive supports ISO or UDF. Use docs, web, or command output as needed.")
 ```
 
-The main agent doesn't see Raven's internal tool calls or raw tool output — just the final findings. Raven parallelizes independent tool calls internally within a single session.
+The main agent doesn't see Raven's internal tool calls or raw tool output — just the final findings. Raven parallelizes independent tool calls internally within a single session.
 
 ## Configuration
 
 ### raven-config.json
 
-Located at `~/.config/opencode/raven-config.json`. Auto-created on first run and auto-migrated on startup when new config fields are added. Default route lists are only applied when the field is missing, so removed tools/MCP prefixes stay removed. Edit manually or use `/raven` commands:
+Located at `~/.config/opencode/raven-config.json`. Auto-created on first run and auto-migrated on startup when new config fields are added. Default route lists are only applied when the field is missing, so removed tools/MCP prefixes stay removed. Edit manually or use `/raven` commands:
 
 ```json
 {
-  "enabled": true,
-  "model": "opencode/deepseek-v4-flash-free",
-  "reasoning_effort": "low",
+  "enabled": true,
+  "model": "opencode/deepseek-v4-flash-free",
+  "reasoning_effort": "low",
   "ravenInstructions": "",
   "routeTools": ["grep", "glob", "webfetch", "fetch", "bash"],
   "routeMcpServers": ["context7", "exa", "grep_app"],
+  "routeToolKeywords": ["search", "context7", "exa", "grep_app"],
   "allowBundledMCPServers": true,
-  "excludeAgents": [],
-  "excludeTools": [],
-  "timeout": 180
+  "excludeAgents": [],
+  "excludeTools": [],
+  "timeout": 180
 }
 ```
 
 | Field | Default | Description |
 |-------|---------|-------------|
-| `enabled` | `true` | Whether tool/MCP routing is active |
-| `model` | *(from Raven.md)* | Override Raven's model without editing package files |
-| `reasoning_effort` | *(from Raven.md)* | Override Raven's reasoning effort (e.g. `"low"`, `"medium"`, `"high"`) |
-| `ravenInstructions` | `""` | Extra instructions appended to Raven's prompt. Useful for custom MCP usage rules. |
+| `enabled` | `true` | Whether tool/MCP routing is active |
+| `model` | *(from Raven.md)* | Override Raven's model without editing package files |
+| `reasoning_effort` | *(from Raven.md)* | Override Raven's reasoning effort (e.g. `"low"`, `"medium"`, `"high"`) |
+| `ravenInstructions` | `""` | Extra instructions appended to Raven's prompt. Useful for custom MCP usage rules. |
 | `routeTools` | built-in search/fetch tools plus `bash` | Exact tool names hard-routed through Raven. `bash` means route only search-like bash commands, not every bash call. e.g. `["grep", "glob", "bash", "linear_search_issues"]` |
 | `routeMcpServers` | `["context7", "exa", "grep_app"]` | MCP server prefixes hard-routed through Raven. `"linear"` routes tools like `linear_search_issues` and `linear_get_issue` |
+| `routeToolKeywords` | `["search", "context7", "exa", "grep_app"]` | Case-insensitive substrings hard-routed through Raven. Catches suffix-style names like `web_search_exa`. |
 | `allowBundledMCPServers` | `true` | Whether Raven auto-registers bundled Context7, Exa, and Grep.app MCP defaults. Existing `opencode.jsonc` MCP entries are never overwritten. |
-| `excludeAgents` | `[]` | Agents that bypass Raven routing (case-insensitive). e.g. `["librarian", "explorer"]` |
-| `excludeTools` | `[]` | Exact tools that never get blocked, even if matched by `routeMcpServers`. e.g. `["my_mcp_validate"]` |
-| `timeout` | `180` | Max seconds for a `raven_seek` call. On timeout the session is kept for inspection. |
-| `stats` | *(auto)* | Session + global context saved by Raven (bytes + tokens). Managed automatically. |
+| `excludeAgents` | `[]` | Agents that bypass Raven routing (case-insensitive). e.g. `["librarian", "explorer"]` |
+| `excludeTools` | `[]` | Exact tools that never get blocked, even if matched by `routeMcpServers`. e.g. `["my_mcp_validate"]` |
+| `timeout` | `180` | Max seconds for a `raven_seek` call. On timeout the session is kept for inspection. |
+| `stats` | *(auto)* | Session + global estimated context saved by Raven (bytes + tokens). Managed automatically. |
 
 ### MCP servers
 
@@ -153,17 +157,17 @@ All three MCPs work without API keys. Add keys for higher rate limits:
 | Exa AI | `https://mcp.exa.ai/mcp` | Free key at [exa.ai](https://exa.ai) — higher limits |
 | Grep.app | `https://mcp.grep.app` | Not available — public API, no key needed |
 
-When `allowBundledMCPServers` is `true`, Raven auto-registers bundled Context7, Exa, and Grep.app MCP defaults. It merges those MCP defaults with your existing `opencode.jsonc` settings, preserving custom headers, URLs, and `enabled: false` overrides. Set `allowBundledMCPServers` to `false` if you do not want Raven to add bundled MCP defaults.
-
-To add other MCPs, configure them in `opencode.jsonc`, then add their server prefix to `routeMcpServers` if you want Raven to route them. Raven does not install arbitrary MCPs from `raven-config.json`.
-
-Use `ravenInstructions` for extra Raven-only guidance, such as how to use custom MCPs:
-
-```json
-{
-  "ravenInstructions": "For Linear requests, prefer assigned open issues and include issue keys in the answer."
-}
-```
+When `allowBundledMCPServers` is `true`, Raven auto-registers bundled Context7, Exa, and Grep.app MCP defaults. It merges those MCP defaults with your existing `opencode.jsonc` settings, preserving custom headers, URLs, and `enabled: false` overrides. Set `allowBundledMCPServers` to `false` if you do not want Raven to add bundled MCP defaults.
+
+To add other MCPs, configure them in `opencode.jsonc`, then add their server prefix to `routeMcpServers` if you want Raven to route them. Raven does not install arbitrary MCPs from `raven-config.json`.
+
+Use `ravenInstructions` for extra Raven-only guidance, such as how to use custom MCPs:
+
+```json
+{
+  "ravenInstructions": "For Linear requests, prefer assigned open issues and include issue keys in the answer."
+}
+```
 
 To add an API key, override the MCP in your `opencode.jsonc` with a `headers` field:
 
@@ -194,53 +198,62 @@ To disable an MCP entirely:
 
 | Hook | What it does |
 |------|--------------|
-| `config` | Registers Raven agent, optionally merges bundled Context7/Exa/Grep.app MCP defaults, loads MCP routing guidance |
-| `tool` | Registers `raven_seek` — creates Raven sessions with timeout, error recovery, timing, and session tree visibility. Tracks context saved for stats (both `raven_seek` and direct `@Raven`). |
-| `chat.message` | Tracks agent ↔ session mapping for allowlist and Raven exclusion |
-| `event` | Shows startup update notifications after the TUI event stream is ready |
-| `command.execute.before` | Handles `/raven on\|off\|route\|update\|model\|effort\|timeout\|stats\|status` |
-| `tool.execute.before` | Hard-blocks configured tools/MCPs for non-Raven, non-excluded agents (respects `excludeTools`). Error output gives the next `raven_seek(query="...")` call. Injects dynamic `<raven_guidance>` with configured routes into subagent prompts. |
-| `tool.execute.after` | Tracks direct `@Raven` calls for context-saved stats. |
-
-### Routed tools (blocked and redirected except for Raven and any agents in `excludeAgents`)
-
-By default, Raven routes these built-in tools and MCP server prefixes:
-
+| `config` | Registers Raven agent, optionally merges bundled Context7/Exa/Grep.app MCP defaults, loads MCP routing guidance |
+| `tool` | Registers `raven_seek` — creates Raven sessions with timeout, error recovery, timing, and session tree visibility. Tracks context saved for stats (both `raven_seek` and direct `@Raven`). |
+| `chat.message` | Tracks agent ↔ session mapping for allowlist and Raven exclusion |
+| `event` | Shows startup update notifications after the TUI event stream is ready |
+| `command.execute.before` | Handles `/raven on\|off\|route\|update\|model\|effort\|timeout\|stats\|status` |
+| `tool.execute.before` | Hard-blocks configured tools/MCPs for non-Raven, non-excluded agents (respects `excludeTools`). Error output gives the next `raven_seek(query="...")` call. Injects dynamic `<raven_guidance>` with configured routes into subagent prompts. |
+| `tool.execute.after` | Tracks direct `@Raven` calls for context-saved stats. |
+
+### Routed tools (blocked and redirected except for Raven and any agents in `excludeAgents`)
+
+By default, Raven routes these built-in tools and MCP server prefixes:
+
 | Config | Default |
 |------|--------|
 | `routeTools` | `grep`, `glob`, `webfetch`, `fetch`, `bash` |
 | `routeMcpServers` | `context7`, `exa`, `grep_app` |
-
-To route another MCP, add its server prefix. For example, `"linear"` routes every tool named `linear_*` through Raven:
-
-```txt
-/raven route mcp add linear
-```
-
-This works for any MCP whose opencode tool names share a prefix. For example, if an MCP exposes tools named `my_mcp_search`, `my_mcp_fetch`, and `my_mcp_get_item`, this routes all of them:
-
-```txt
-/raven route mcp add my_mcp
-```
-
+| `routeToolKeywords` | `search`, `context7`, `exa`, `grep_app` |
+
+To route another MCP, add its server prefix. For example, `"linear"` routes every tool named `linear_*` through Raven:
+
+```txt
+/raven route mcp add linear
+```
+
+This works for any MCP whose opencode tool names share a prefix. For example, if an MCP exposes tools named `my_mcp_search`, `my_mcp_fetch`, and `my_mcp_get_item`, this routes all of them:
+
+```txt
+/raven route mcp add my_mcp
+```
+
 The prefix must match the actual tool name before `_`. If the tools are named `project_search`, add `project`, not the display name of the MCP. Matching is case-insensitive.
 
-If an MCP is routed but one tool should remain direct, add the exact tool to `excludeTools`:
-
-```json
-{
-  "routeMcpServers": ["context7", "exa", "grep_app", "my_mcp"],
-  "excludeTools": ["my_mcp_validate"]
-}
-```
-
-To route one specific tool without routing the whole MCP server:
+If a server uses suffix-style or mixed tool names, route by keyword instead. For example, `exa` catches names like `web_search_exa` and `web_fetch_exa`:
 
 ```txt
-/raven route tool add linear_search_issues
+/raven route keyword add exa
 ```
+
+Keyword matching is case-insensitive and checks whether the tool name contains the keyword anywhere.
+
+If an MCP is routed but one tool should remain direct, add the exact tool to `excludeTools`:
+
+```json
+{
+  "routeMcpServers": ["context7", "exa", "grep_app", "my_mcp"],
+  "excludeTools": ["my_mcp_validate"]
+}
+```
+
+To route one specific tool without routing the whole MCP server:
+
+```txt
+/raven route tool add linear_search_issues
+```
 
-**Bash commands** — intercepted only while `bash` is included in `routeTools` and the command matches a primary search/discovery pattern:
+**Bash commands** — intercepted only while `bash` is included in `routeTools` and the command matches a primary search/discovery pattern:
 
 | Pattern | Examples |
 |---------|----------|
@@ -248,33 +261,35 @@ To route one specific tool without routing the whole MCP server:
 | Filesystem exploration | `Get-ChildItem -Recurse`, `gci -Recurse`, `Get-ChildItem -Filter`, `find -name`, `find -type`, `ls -R`, `ls --recursive`, `dir /s` |
 | Shell bypass | `cmd /c dir /s`, `cmd /c findstr`, `cmd /c find`, `cmd /c tree` |
 
-**Unrestricted for non-Raven agents**: `read`, `task`, `subtask`, `raven_seek`, non-routed tools, and non-search `bash` commands.
+**Unrestricted for non-Raven agents**: `read`, `task`, `subtask`, `raven_seek`, non-routed tools, and non-search `bash` commands.
 
-**Allowed output filters**: Piped filters like `command | grep ...`, `command | rg ...`, `command | findstr ...`, and `command | head ...` are allowed. Raven only blocks search commands when they are used as primary discovery commands, not when they filter bounded output from another command.
-
-To stop routing search-like bash commands, remove `bash` from `routeTools`:
-
-```txt
-/raven route tool remove bash
-```
+**Allowed output filters**: Piped filters like `command | grep ...`, `command | rg ...`, `command | findstr ...`, and `command | head ...` are allowed. Raven only blocks search commands when they are used as primary discovery commands, not when they filter bounded output from another command.
+
+To stop routing search-like bash commands, remove `bash` from `routeTools`:
+
+```txt
+/raven route tool remove bash
+```
 
 **Bash quote stripping**: Quoted content in bash commands is stripped before pattern matching — `echo "use grep here"` won't falsely trigger blocking.
 
 **Comment stripping**: Shell comments are stripped before matching — `# use grep later` won't falsely trigger blocking.
 
-**Subagent guidance**: Every non-Raven, non-excluded subagent gets `<raven_guidance>` injected into its prompt at spawn time.
-
-The injected guidance includes the current `routeTools` and `routeMcpServers`, including user-added custom MCP prefixes, so subagents know which calls must go through `raven_seek`.
-
-### What Raven Saves
-
-Raven saves context from tool call results and raw MCP output by moving the work into a Raven session and returning a compact answer. It does not currently save context from MCP tool schemas that opencode loads into the main session when an MCP is enabled globally.
-
-This means large MCPs may still increase the main session's starting context. Raven still prevents repeated verbose tool outputs from accumulating in the main session.
-
-## Agent capabilities
+**Subagent guidance**: Every non-Raven, non-excluded subagent gets `<raven_guidance>` injected into its prompt at spawn time.
+
+The injected guidance includes the current `routeTools` and `routeMcpServers`, including user-added custom MCP prefixes, so subagents know which calls must go through `raven_seek`.
+
+### What Raven Saves
+
+Raven saves context from tool call results and raw MCP output by moving the work into a Raven session and returning a compact answer. It does not currently save context from MCP tool schemas that opencode loads into the main session when an MCP is enabled globally.
+
+This means large MCPs may still increase the main session's starting context. Raven still prevents repeated verbose tool outputs from accumulating in the main session.
+
+`/raven stats` uses a balanced estimate: Raven's final session token total minus the first Raven assistant turn's input/cache baseline, then minus the compact answer returned to the main session. This counts tool/web/MCP result context Raven handled while avoiding Raven's starting prompt and tool-schema overhead.
+
+## Agent capabilities
 
-Raven itself has access to these tools (blocked for other agents when configured by the plugin):
+Raven itself has access to these tools (blocked for other agents when configured by the plugin):
 
 | Tool / MCP | Purpose |
 |------------|---------|

package/index.ts

@@ -13,28 +13,35 @@ const PACKAGE_JSON = JSON.parse(readFileSync(join(PKG_DIR, "package.json"), "utf
 const PACKAGE_NAME = PACKAGE_JSON.name || "opencode-raven"
 const PACKAGE_VERSION = PACKAGE_JSON.version || "0.0.0"
 
-// ── Tools/MCPs that should be intercepted for non-Raven agents ──
-const DEFAULT_ROUTE_TOOLS = [
-  "grep",
-  "glob",
-  "webfetch",
-  "fetch",
-  "bash",
-]
-
+// ── Tools/MCPs that should be intercepted for non-Raven agents ──
+const DEFAULT_ROUTE_TOOLS = [
+  "grep",
+  "glob",
+  "webfetch",
+  "fetch",
+  "bash",
+]
+
 const DEFAULT_ROUTE_MCP_SERVERS = [
   "context7",
   "exa",
   "grep_app",
 ]
 
-const DEFAULT_MCP_SERVERS: Record<string, string> = {
-  context7: "https://mcp.context7.com/mcp",
-  exa: "https://mcp.exa.ai/mcp",
-  grep_app: "https://mcp.grep.app",
-}
-
-const NEVER_ROUTE_TOOLS = new Set(["raven_seek", "task", "subtask"])
+const DEFAULT_ROUTE_TOOL_KEYWORDS = [
+  "search",
+  "context7",
+  "exa",
+  "grep_app",
+]
+
+const DEFAULT_MCP_SERVERS: Record<string, string> = {
+  context7: "https://mcp.context7.com/mcp",
+  exa: "https://mcp.exa.ai/mcp",
+  grep_app: "https://mcp.grep.app",
+}
+
+const NEVER_ROUTE_TOOLS = new Set(["raven_seek", "task", "subtask"])
 
 // ── Bash commands that look like search workarounds ──
 const SEARCH_BASH_RE = /\b(?:rg|ripgrep|grep|egrep|fgrep|git\s+grep|ack|ag\b|findstr|Select-String)\b|\b(?:Get-ChildItem|gci)\b(?=[^|;&\n]*(?:-Recurse|-Filter|-Include|\s-[A-Za-z]*r[A-Za-z]*\b))|\bdir\b(?=[^|;&\n]*(?:[/-][sS]\b|-Recurse|-Filter|-Include))|\bls\b(?=[^|;&\n]*(?:\s-[A-Za-z]*R[A-Za-z]*\b|--recursive\b))|\bfind\b\s+.*(?:-name|-type)\b/i
@@ -107,36 +114,38 @@ function isSearchBash(tool: string, args: any): boolean {
 }
 
 // ── Config file shape ──
-interface RavenConfig {
-  enabled: boolean
-  model?: string
-  reasoning_effort?: string
+interface RavenConfig {
+  enabled: boolean
+  model?: string
+  reasoning_effort?: string
   ravenInstructions?: string
   routeTools?: string[]
   routeMcpServers?: string[]
+  routeToolKeywords?: string[]
   allowBundledMCPServers?: boolean
-  excludeAgents?: string[]
-  excludeTools?: string[]
-  timeout?: number
-  stats?: { bytes: number }
-}
+  excludeAgents?: string[]
+  excludeTools?: string[]
+  timeout?: number
+  stats?: { bytes: number }
+}
 
 // ── Parse Raven.md frontmatter ──
 const ravenMd = readFileSync(RAVEN_MD, "utf-8")
 const { frontmatter: fm, prompt: ravenPrompt } = parseRavenMd(ravenMd)
 
 const DEFAULT_CONFIG: RavenConfig = {
-  enabled: true,
-  model: fm.model,
-  reasoning_effort: fm.reasoning_effort,
+  enabled: true,
+  model: fm.model,
+  reasoning_effort: fm.reasoning_effort,
   ravenInstructions: "",
   routeTools: DEFAULT_ROUTE_TOOLS,
   routeMcpServers: DEFAULT_ROUTE_MCP_SERVERS,
+  routeToolKeywords: DEFAULT_ROUTE_TOOL_KEYWORDS,
   allowBundledMCPServers: true,
-  excludeAgents: [],
-  excludeTools: [],
-  timeout: 180,
-}
+  excludeAgents: [],
+  excludeTools: [],
+  timeout: 180,
+}
 
 function parseRavenMd(raw: string): { frontmatter: Record<string, any>; prompt: string } {
   const parts = raw.split("---")
@@ -208,21 +217,21 @@ const KNOWN_KEYS = new Set([
   "temperature", "top_p", "variant",
 ])
 
-function extractOptions(fm: Record<string, any>): Record<string, any> {
-  const options: Record<string, any> = {}
-  for (const key of Object.keys(fm)) {
-    if (!KNOWN_KEYS.has(key)) options[key] = fm[key]
-  }
-  return options
-}
-
-function uniqueStrings(value: unknown, fallback: string[] = []): string[] {
-  const source = Array.isArray(value) ? value : fallback
-  return [...new Set(source.filter((item) => typeof item === "string" && item.trim()).map((item) => item.trim()))]
-}
-
-// ── Plugin ──
-export default ((input: PluginInput) => {
+function extractOptions(fm: Record<string, any>): Record<string, any> {
+  const options: Record<string, any> = {}
+  for (const key of Object.keys(fm)) {
+    if (!KNOWN_KEYS.has(key)) options[key] = fm[key]
+  }
+  return options
+}
+
+function uniqueStrings(value: unknown, fallback: string[] = []): string[] {
+  const source = Array.isArray(value) ? value : fallback
+  return [...new Set(source.filter((item) => typeof item === "string" && item.trim()).map((item) => item.trim()))]
+}
+
+// ── Plugin ──
+export default ((input: PluginInput) => {
   const client = input.client
 
   // Config file lives in the global opencode config directory
@@ -232,17 +241,18 @@ export default ((input: PluginInput) => {
     const source = raw && typeof raw === "object" ? raw : {}
     const normalized: RavenConfig = { ...DEFAULT_CONFIG, ...source }
 
-    normalized.enabled = source.enabled !== false
-    normalized.model = typeof source.model === "string" ? source.model : DEFAULT_CONFIG.model
-    normalized.reasoning_effort = typeof source.reasoning_effort === "string" ? source.reasoning_effort : DEFAULT_CONFIG.reasoning_effort
+    normalized.enabled = source.enabled !== false
+    normalized.model = typeof source.model === "string" ? source.model : DEFAULT_CONFIG.model
+    normalized.reasoning_effort = typeof source.reasoning_effort === "string" ? source.reasoning_effort : DEFAULT_CONFIG.reasoning_effort
     normalized.ravenInstructions = typeof source.ravenInstructions === "string" ? source.ravenInstructions : DEFAULT_CONFIG.ravenInstructions
     normalized.routeTools = uniqueStrings(source.routeTools, DEFAULT_ROUTE_TOOLS)
     normalized.routeMcpServers = uniqueStrings(source.routeMcpServers, DEFAULT_ROUTE_MCP_SERVERS)
+    normalized.routeToolKeywords = uniqueStrings(source.routeToolKeywords, DEFAULT_ROUTE_TOOL_KEYWORDS)
     normalized.allowBundledMCPServers = source.allowBundledMCPServers !== false
-    normalized.excludeAgents = uniqueStrings(source.excludeAgents)
-    normalized.excludeTools = uniqueStrings(source.excludeTools)
-    normalized.timeout = typeof source.timeout === "number" ? source.timeout : DEFAULT_CONFIG.timeout
-    normalized.stats = source.stats || undefined
+    normalized.excludeAgents = uniqueStrings(source.excludeAgents)
+    normalized.excludeTools = uniqueStrings(source.excludeTools)
+    normalized.timeout = typeof source.timeout === "number" ? source.timeout : DEFAULT_CONFIG.timeout
+    normalized.stats = source.stats || undefined
 
     return normalized
   }
@@ -273,7 +283,6 @@ export default ((input: PluginInput) => {
   let config = loadConfig()
   const ravenSessions = new Set<string>()
   const ravenTaskCalls = new Set<string>()
-  const ravenTaskPrompts = new Map<string, number>()
   const sessionAgents = new Map<string, string>()
   const ravenSessionParents = new Map<string, string>()
   let updateInfo: { current: string; latest?: string; available: boolean } | undefined
@@ -287,65 +296,68 @@ export default ((input: PluginInput) => {
     return config.excludeAgents.some((a) => a.toLowerCase() === lower)
   }
 
-  function ravenGuidance(): string {
+  function ravenGuidance(): string {
     const tools = config.routeTools?.length ? config.routeTools.join(", ") : "none"
     const mcps = config.routeMcpServers?.length ? config.routeMcpServers.map((server) => `${server}_*`).join(", ") : "none"
-    return `Some tools/MCPs are routed through Raven to save context. Routed tools: ${tools}. Routed MCP prefixes: ${mcps}. If one is blocked, your next tool call should be raven_seek(query="<same request>"). Include the original tool/MCP name and relevant arguments.`
+    const keywords = config.routeToolKeywords?.length ? config.routeToolKeywords.join(", ") : "none"
+    return `Some tools/MCPs are routed through Raven to save context. Routed tools: ${tools}. Routed MCP prefixes: ${mcps}. Routed tool-name keywords: ${keywords}. If one is blocked, your next tool call should be raven_seek(query="<same request>"). Include the original tool/MCP name and relevant arguments.`
   }
-
-  function isRouteConfigured(toolName: string): boolean {
-    const tool = toolName.toLowerCase()
+
+  function isRouteConfigured(toolName: string): boolean {
+    const tool = toolName.toLowerCase()
     if (NEVER_ROUTE_TOOLS.has(tool)) return false
     if (config.routeTools?.some((name) => name.toLowerCase() === tool)) return true
+    if (config.routeToolKeywords?.some((keyword) => tool.includes(keyword.toLowerCase()))) return true
     return config.routeMcpServers?.some((server) => tool.startsWith(`${server.toLowerCase()}_`)) ?? false
   }
-
-  function compactArgs(value: any): any {
-    if (Array.isArray(value)) {
-      return value.map(compactArgs).filter((item) => item !== undefined)
-    }
-    if (!value || typeof value !== "object") return value
-    const result: Record<string, any> = {}
-    for (const [key, raw] of Object.entries(value)) {
-      const item = compactArgs(raw)
-      if (item === undefined || item === null || item === "") continue
-      if (Array.isArray(item) && item.length === 0) continue
-      if (typeof item === "object" && !Array.isArray(item) && Object.keys(item).length === 0) continue
-      result[key] = item
-    }
-    return result
-  }
-
-  function attemptedQuery(tool: string, args: any): string {
-    const compact = compactArgs(args)
-    if (!compact || typeof compact !== "object") return `${tool}: ${JSON.stringify(compact)}`
-    const direct = compact.query ?? compact.pattern ?? compact.url ?? compact.urls ?? compact.command ?? compact.path ?? compact.filePath
-    const value = direct !== undefined ? direct : compact
-    const text = typeof value === "string" ? value : JSON.stringify(value)
-    const query = value === compact ? `${tool} ${text}` : `${tool}: ${text}`
-    return query.length > 300 ? `${query.slice(0, 297)}...` : query
-  }
 
-  function rerouteMessage(tool: string, args: any): string {
-    return `The '${tool}' tool call is blocked by Raven. Your next tool call should be raven_seek(query="${attemptedQuery(tool, args).replace(/"/g, "'")}").`
-  }
-
-  function routeSummary(): string {
+  function compactArgs(value: any): any {
+    if (Array.isArray(value)) {
+      return value.map(compactArgs).filter((item) => item !== undefined)
+    }
+    if (!value || typeof value !== "object") return value
+    const result: Record<string, any> = {}
+    for (const [key, raw] of Object.entries(value)) {
+      const item = compactArgs(raw)
+      if (item === undefined || item === null || item === "") continue
+      if (Array.isArray(item) && item.length === 0) continue
+      if (typeof item === "object" && !Array.isArray(item) && Object.keys(item).length === 0) continue
+      result[key] = item
+    }
+    return result
+  }
+
+  function attemptedQuery(tool: string, args: any): string {
+    const compact = compactArgs(args)
+    if (!compact || typeof compact !== "object") return `${tool}: ${JSON.stringify(compact)}`
+    const direct = compact.query ?? compact.pattern ?? compact.url ?? compact.urls ?? compact.command ?? compact.path ?? compact.filePath
+    const value = direct !== undefined ? direct : compact
+    const text = typeof value === "string" ? value : JSON.stringify(value)
+    const query = value === compact ? `${tool} ${text}` : `${tool}: ${text}`
+    return query.length > 300 ? `${query.slice(0, 297)}...` : query
+  }
+
+  function rerouteMessage(tool: string, args: any): string {
+    return `The '${tool}' tool call is blocked by Raven. Your next tool call should be raven_seek(query="${attemptedQuery(tool, args).replace(/"/g, "'")}").`
+  }
+
+  function routeSummary(): string {
     const tools = config.routeTools?.length ? config.routeTools.join(", ") : "(none)"
     const mcps = config.routeMcpServers?.length ? config.routeMcpServers.join(", ") : "(none)"
-    return `Raven routed tools/MCPs:\n  Tools: ${tools}\n  MCP servers: ${mcps}`
-  }
-
-  function mcpSummary(): string {
-    return `Raven bundled MCPs: ${config.allowBundledMCPServers === false ? "disabled" : Object.keys(DEFAULT_MCP_SERVERS).join(", ")}`
-  }
-
-  function ravenAgentPrompt(): string {
-    const extra = config.ravenInstructions?.trim()
-    return extra ? `${ravenPrompt}\n\nAdditional user instructions:\n${extra}` : ravenPrompt
+    const keywords = config.routeToolKeywords?.length ? config.routeToolKeywords.join(", ") : "(none)"
+    return `Raven routed tools/MCPs:\n  Tools: ${tools}\n  MCP servers: ${mcps}\n  Tool keywords: ${keywords}`
   }
 
-  // ── Context saved by Raven delegation ──
+  function mcpSummary(): string {
+    return `Raven bundled MCPs: ${config.allowBundledMCPServers === false ? "disabled" : Object.keys(DEFAULT_MCP_SERVERS).join(", ")}`
+  }
+
+  function ravenAgentPrompt(): string {
+    const extra = config.ravenInstructions?.trim()
+    return extra ? `${ravenPrompt}\n\nAdditional user instructions:\n${extra}` : ravenPrompt
+  }
+
+  // ── Context saved by Raven delegation ──
   let sessionBytes = 0
   let totalBytes = config.stats?.bytes ?? 0
 
@@ -400,18 +412,25 @@ export default ((input: PluginInput) => {
     return { current: PACKAGE_VERSION, latest, available: !!latest && compareVersions(latest, PACKAGE_VERSION) > 0 }
   }
 
-  async function countRavenSessionBytes(sessionId: string): Promise<number> {
-    // Get last assistant message token counts (matches TUI bottom bar)
+  async function countRavenSavedCandidateBytes(sessionId: string): Promise<number> {
     const messagesResp = await client.session.messages({ path: { id: sessionId }, query: { limit: 200 } })
     const messages = (messagesResp as any)?.data ?? []
-    // Find last assistant message with output tokens (same logic as TUI subagent-footer.tsx)
-    const last = [...messages].reverse().find((m: any) =>
+    const assistantMessages = messages.filter((m: any) =>
       m?.info?.role === "assistant" && m?.info?.tokens?.output > 0
     )
+    const first = assistantMessages[0]
+    const last = assistantMessages[assistantMessages.length - 1]
     const t = last?.info?.tokens
+    const firstTokens = first?.info?.tokens
     if (!t) return 0
+
+    // Balanced estimate: total Raven context minus the first-turn prompt/schema/cache baseline.
     const totalTokens = (t.input ?? 0) + (t.output ?? 0) + (t.reasoning ?? 0) + (t.cache?.read ?? 0) + (t.cache?.write ?? 0)
-    return totalTokens * 4
+    const baselineTokens = firstTokens
+      ? (firstTokens.input ?? 0) + (firstTokens.cache?.read ?? 0) + (firstTokens.cache?.write ?? 0)
+      : 0
+    const savedCandidateTokens = Math.max(0, totalTokens - baselineTokens)
+    return savedCandidateTokens * 4
   }
 
   async function getUpdateInfo(): Promise<{ current: string; latest?: string; available: boolean }> {
@@ -492,13 +511,13 @@ export default ((input: PluginInput) => {
 
   return {
     config(configInput: any) {
-      // Bundled MCP defaults. Existing opencode.jsonc entries are merged, not overwritten.
-      if (config.allowBundledMCPServers !== false) {
-        configInput.mcp = configInput.mcp || {}
-        for (const [key, url] of Object.entries(DEFAULT_MCP_SERVERS)) {
-          ensureRemoteMcp(configInput, key, url)
-        }
-      }
+      // Bundled MCP defaults. Existing opencode.jsonc entries are merged, not overwritten.
+      if (config.allowBundledMCPServers !== false) {
+        configInput.mcp = configInput.mcp || {}
+        for (const [key, url] of Object.entries(DEFAULT_MCP_SERVERS)) {
+          ensureRemoteMcp(configInput, key, url)
+        }
+      }
 
       // Inject MCP guidance as a startup instruction file (absolute path for npm compat)
       configInput.instructions = configInput.instructions || []
@@ -518,27 +537,27 @@ export default ((input: PluginInput) => {
           ...(config.reasoning_effort ? { reasoning_effort: config.reasoning_effort } : {}),
         },
         permission: fm.permission || {},
-        prompt: ravenAgentPrompt(),
-      }
+        prompt: ravenAgentPrompt(),
+      }
 
       // Register /raven command
       configInput.command = configInput.command || {}
       if (!configInput.command.raven) {
-        configInput.command.raven = {
-          template: "Manage Raven: /raven on|off|route|update|model <name>|status",
-          description: "Toggle Raven routing, manage routed tools/MCPs, or change Raven's model",
-        }
+        configInput.command.raven = {
+          template: "Manage Raven: /raven on|off|route|update|model <name>|status",
+          description: "Toggle Raven routing, manage routed tools/MCPs, or change Raven's model",
+        }
       }
 
       updateToastPending = true
     },
 
-    // Register raven_seek tool — lets agents with task:false still delegate through Raven
+    // Register raven_seek tool — lets agents with task:false still delegate through Raven
     tool: {
       "raven_seek": tool({
-        description: "Unified Raven delegation tool. Use this whenever a tool/MCP is blocked by Raven, or when grep, glob, WebFetch/fetch, websearch, docs lookup, GitHub search, or search-like bash would be used. Handles routed MCP requests, local codebase search, filesystem discovery, specific URL/page reads, web/docs research, GitHub examples, and command-output/system inspection via Raven.",
+        description: "Unified Raven delegation tool. Use this whenever a tool/MCP is blocked by Raven, or when grep, glob, WebFetch/fetch, websearch, docs lookup, GitHub search, or search-like bash would be used. Handles routed MCP requests, local codebase search, filesystem discovery, specific URL/page reads, web/docs research, GitHub examples, and command-output/system inspection via Raven.",
         args: {
-          query: tool.schema.string().describe("What Raven should do. Include the original blocked tool/MCP request and relevant args, exact URLs when replacing WebFetch, and commands/output checks when replacing grep/rg/head over command output."),
+          query: tool.schema.string().describe("What Raven should do. Include the original blocked tool/MCP request and relevant args, exact URLs when replacing WebFetch, and commands/output checks when replacing grep/rg/head over command output."),
         },
         async execute(args, context) {
           const started = Date.now()
@@ -593,23 +612,21 @@ export default ((input: PluginInput) => {
               .map((p: any) => p.text)
             const output = textParts.join("\n") || "Raven returned no results."
 
-            // Get total Raven session context and subtract input/output to get context saved
-            let totalProcessed = 0
+            // Context saved = Raven output/reasoning/cache context - compact answer returned to main session.
+            let savedCandidate = 0
             try {
-              totalProcessed = await countRavenSessionBytes(sessionId)
+              savedCandidate = await countRavenSavedCandidateBytes(sessionId)
             } catch { /* best-effort */ }
-            if (totalProcessed <= 0) {
+            if (savedCandidate <= 0) {
               for (const part of parts) {
-                if (part.text) totalProcessed += part.text.length
-                if (part.args) totalProcessed += JSON.stringify(part.args).length
-                if (part.content) totalProcessed += typeof part.content === "string" ? part.content.length : JSON.stringify(part.content).length
+                if (part.args) savedCandidate += JSON.stringify(part.args).length
+                if (part.content) savedCandidate += typeof part.content === "string" ? part.content.length : JSON.stringify(part.content).length
               }
             }
-            // Context saved = total session context − input query − compact answer returned
-            const saved = Math.max(0, totalProcessed - output.length - String(args.query).length)
+            const saved = Math.max(0, savedCandidate - output.length)
             addBytes(saved)
 
-            return { title: "Raven Seek", metadata: { sessionId }, output: `${output}\n\n*Raven searched for ${elapsed}s — ${formatBytes(totalProcessed)} processed, ${formatTokens(totalProcessed)} tokens*` }
+            return { title: "Raven Seek", metadata: { sessionId }, output: `${output}\n\n*Raven searched for ${elapsed}s — ${formatBytes(savedCandidate)} handled, ${formatTokens(savedCandidate)} tokens*` }
           } catch (err: any) {
             const elapsed = ((Date.now() - started) / 1000).toFixed(1)
             const msg = String(err?.message ?? err ?? "").toLowerCase()
@@ -648,44 +665,44 @@ export default ((input: PluginInput) => {
       setTimeout(() => void notifyIfUpdateAvailable(), 500)
     },
 
-    // /raven on|off|route|model <name>|effort <value>|timeout <seconds>|stats|status
+    // /raven on|off|route|model <name>|effort <value>|timeout <seconds>|stats|status
     async "command.execute.before"(input: any, output: any) {
       if (input.command !== "raven") return
       output.parts.length = 0
       const raw = input.arguments.trim()
       const arg = raw.toLowerCase()
 
-      if (arg === "on") {
-        config.enabled = true
-        saveConfig(config)
-        output.parts.push({ type: "text", text: "Raven tool/MCP routing enabled. Non-Raven agents will be redirected to raven_seek for configured tools." })
-      } else if (arg === "off") {
-        config.enabled = false
-        saveConfig(config)
-        output.parts.push({ type: "text", text: "Raven tool/MCP routing disabled. All agents can use tools directly." })
-      } else if (arg === "stats") {
-        output.parts.push({ type: "text", text: `Raven context saved:\n  This session: ${formatBytes(sessionBytes)} (~${formatTokens(sessionBytes)} context)\n  All time: ${formatBytes(totalBytes)} (~${formatTokens(totalBytes)} context)` })
-      } else if (arg === "route") {
-        output.parts.push({ type: "text", text: `${routeSummary()}\n\nUsage:\n  /raven route tool add <tool_name>\n  /raven route tool remove <tool_name>\n  /raven route mcp add <server_name>\n  /raven route mcp remove <server_name>` })
+      if (arg === "on") {
+        config.enabled = true
+        saveConfig(config)
+        output.parts.push({ type: "text", text: "Raven tool/MCP routing enabled. Non-Raven agents will be redirected to raven_seek for configured tools." })
+      } else if (arg === "off") {
+        config.enabled = false
+        saveConfig(config)
+        output.parts.push({ type: "text", text: "Raven tool/MCP routing disabled. All agents can use tools directly." })
+      } else if (arg === "stats") {
+        output.parts.push({ type: "text", text: `Raven context saved:\n  This session: ${formatBytes(sessionBytes)} (~${formatTokens(sessionBytes)} context)\n  All time: ${formatBytes(totalBytes)} (~${formatTokens(totalBytes)} context)` })
+      } else if (arg === "route") {
+        output.parts.push({ type: "text", text: `${routeSummary()}\n\nUsage:\n  /raven route tool add <tool_name>\n  /raven route tool remove <tool_name>\n  /raven route mcp add <server_name>\n  /raven route mcp remove <server_name>\n  /raven route keyword add <keyword>\n  /raven route keyword remove <keyword>` })
       } else if (arg.startsWith("route ")) {
         const parts = raw.split(/\s+/)
         const kind = parts[1]?.toLowerCase()
         const action = parts[2]?.toLowerCase()
         const name = parts.slice(3).join(" ").trim()
-        const key = kind === "tool" ? "routeTools" : kind === "mcp" || kind === "server" ? "routeMcpServers" : undefined
+        const key = kind === "tool" ? "routeTools" : kind === "mcp" || kind === "server" ? "routeMcpServers" : kind === "keyword" ? "routeToolKeywords" : undefined
 
         if (!key || !["add", "remove", "rm"].includes(action) || !name) {
-          output.parts.push({ type: "text", text: "Usage:\n  /raven route tool add <tool_name>\n  /raven route tool remove <tool_name>\n  /raven route mcp add <server_name>\n  /raven route mcp remove <server_name>" })
-        } else {
-          const values = uniqueStrings(config[key])
-          const exists = values.some((value) => value.toLowerCase() === name.toLowerCase())
-          config[key] = action === "add"
-            ? exists ? values : [...values, name]
-            : values.filter((value) => value.toLowerCase() !== name.toLowerCase())
-          saveConfig(config)
-          output.parts.push({ type: "text", text: routeSummary() })
-        }
-      } else if (arg === "update") {
+          output.parts.push({ type: "text", text: "Usage:\n  /raven route tool add <tool_name>\n  /raven route tool remove <tool_name>\n  /raven route mcp add <server_name>\n  /raven route mcp remove <server_name>\n  /raven route keyword add <keyword>\n  /raven route keyword remove <keyword>" })
+        } else {
+          const values = uniqueStrings(config[key])
+          const exists = values.some((value) => value.toLowerCase() === name.toLowerCase())
+          config[key] = action === "add"
+            ? exists ? values : [...values, name]
+            : values.filter((value) => value.toLowerCase() !== name.toLowerCase())
+          saveConfig(config)
+          output.parts.push({ type: "text", text: routeSummary() })
+        }
+      } else if (arg === "update") {
         try {
           const info = await refreshUpdateInfo()
           if (!info.latest) {
@@ -738,8 +755,8 @@ export default ((input: PluginInput) => {
             ? `Update: ${info.latest} available. Run /raven update, then restart opencode.`
             : `Update: up to date${info.latest ? ` (latest ${info.latest})` : ""}.`
         } catch { /* keep fallback */ }
-        output.parts.push({ type: "text", text: `Raven is ${enabled}. Version: ${PACKAGE_VERSION}. Model: ${model}. Reasoning: ${effort}. Timeout: ${timeout}s\n${update}\n\n${routeSummary()}\n\n${mcpSummary()}\n\nRaven context saved:\n  This session: ${formatBytes(sessionBytes)} (~${formatTokens(sessionBytes)} context)\n  All time: ${formatBytes(totalBytes)} (~${formatTokens(totalBytes)} context)\n\nCommands:\n  /raven on      — enable tool/MCP routing\n  /raven off     — disable tool/MCP routing\n  /raven route   — show or edit routed tools/MCP servers\n  /raven update  — check npm, clear plugin cache if newer, then restart opencode\n  /raven model <name> — change Raven's model (requires restart)\n  /raven effort <value> — change Raven's reasoning effort (requires restart)\n  /raven timeout <seconds> — change raven_seek timeout\n  /raven stats   — show context saved` })
-      }
+        output.parts.push({ type: "text", text: `Raven is ${enabled}. Version: ${PACKAGE_VERSION}. Model: ${model}. Reasoning: ${effort}. Timeout: ${timeout}s\n${update}\n\n${routeSummary()}\n\n${mcpSummary()}\n\nRaven context saved:\n  This session: ${formatBytes(sessionBytes)} (~${formatTokens(sessionBytes)} context)\n  All time: ${formatBytes(totalBytes)} (~${formatTokens(totalBytes)} context)\n\nCommands:\n  /raven on      — enable tool/MCP routing\n  /raven off     — disable tool/MCP routing\n  /raven route   — show or edit routed tools/MCP servers/keywords\n  /raven update  — check npm, clear plugin cache if newer, then restart opencode\n  /raven model <name> — change Raven's model (requires restart)\n  /raven effort <value> — change Raven's reasoning effort (requires restart)\n  /raven timeout <seconds> — change raven_seek timeout\n  /raven stats   — show context saved` })
+      }
     },
 
     "tool.execute.before"(input: any, output: any) {
@@ -750,62 +767,50 @@ export default ((input: PluginInput) => {
       if (!config.enabled) return
       if (ravenSessions.has(input.sessionID)) return
       if (isExcluded(sessionAgents.get(input.sessionID))) return
-      if (config.excludeTools?.some((name) => name.toLowerCase() === input.tool.toLowerCase())) return
+      if (config.excludeTools?.some((name) => name.toLowerCase() === input.tool.toLowerCase())) return
 
       // ── Subagent prompt injection: inject Raven guidance into every subagent ──
       if ((input.tool === "task" || input.tool === "subtask") && output.args) {
         const subagentType = input.tool === "task" ? (output.args.subagent_type ?? "") : ""
         if (subagentType === "raven") {
           ravenTaskCalls.add(input.callID)
-          const promptField = ["prompt", "description", "request", "objective", "query"].find(
-            (f) => f in output.args
-          ) ?? "prompt"
-          ravenTaskPrompts.set(input.callID, String(output.args[promptField] ?? "").length)
         }
         if (subagentType !== "raven" && !isExcluded(subagentType)) {
           const field = ["prompt", "description", "request", "objective", "query"].find(
             (f) => f in output.args
           ) ?? "prompt"
-          output.args[field] = `${output.args[field] ?? ""}\n\n<raven_guidance>\n${ravenGuidance()}\n</raven_guidance>`
-        }
-      }
+          output.args[field] = `${output.args[field] ?? ""}\n\n<raven_guidance>\n${ravenGuidance()}\n</raven_guidance>`
+        }
+      }
 
-      // ── Block routed tools/MCPs for non-Raven agents ──
-      const shouldRouteTool = input.tool === "bash" ? false : isRouteConfigured(input.tool)
-      const isSearchBashCmd = isRouteConfigured("bash") && isSearchBash(input.tool, output.args || input.args)
-
-      if (shouldRouteTool || isSearchBashCmd) {
-        const args = compactArgs(output.args || input.args)
-        if (output.args && typeof output.args === "object") output.args = args
-        throw new Error(rerouteMessage(input.tool, args))
-      }
+      // ── Block routed tools/MCPs for non-Raven agents ──
+      const shouldRouteTool = input.tool === "bash" ? false : isRouteConfigured(input.tool)
+      const isSearchBashCmd = isRouteConfigured("bash") && isSearchBash(input.tool, output.args || input.args)
+
+      if (shouldRouteTool || isSearchBashCmd) {
+        const args = compactArgs(output.args || input.args)
+        if (output.args && typeof output.args === "object") output.args = args
+        throw new Error(rerouteMessage(input.tool, args))
+      }
     },
 
     "tool.execute.after"(input: any, output: any) {
       if (ravenTaskCalls.has(input.callID)) {
         ravenTaskCalls.delete(input.callID)
-        const promptBytes = ravenTaskPrompts.get(input.callID) ?? 0
-        ravenTaskPrompts.delete(input.callID)
         // Try task metadata first (built-in tools preserve metadata)
         const ravenSessionId = output.metadata?.sessionId ?? ravenSessionParents.get(input.sessionID)
         if (ravenSessionId) {
           if (ravenSessionParents.has(input.sessionID)) ravenSessionParents.delete(input.sessionID)
-          void countRavenSessionBytes(ravenSessionId)
+          void countRavenSavedCandidateBytes(ravenSessionId)
             .then((total) => {
-              const saved = Math.max(0, total - promptBytes - String(output.output ?? "").length)
+              const saved = Math.max(0, total - String(output.output ?? "").length)
               if (saved > 0) addBytes(saved)
             })
             .catch(() => {
-              const outputLen = String(output.output ?? "").length
-              const saved = Math.max(0, outputLen - promptBytes)
-              if (saved > 0) addBytes(saved)
+              // Without token metadata we cannot separate saved context from the compact answer.
             })
-        } else {
-          const outputLen = String(output.output ?? "").length
-          const saved = Math.max(0, outputLen - promptBytes)
-          if (saved > 0) addBytes(saved)
         }
       }
     },
-  }
-}) satisfies Plugin
+  }
+}) satisfies Plugin

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-raven",
-  "version": "2.0.0",
-  "description": "Hard tool/MCP rerouter for opencode — blocks configured tools and routes them through a Raven agent to reduce context flooding",
+  "version": "2.0.1",
+  "description": "Hard tool/MCP rerouter for opencode — avoids flooding and wasted context from searches, docs, web, GitHub examples, and verbose MCP calls",
   "main": "./index.ts",
   "exports": {
     ".": "./index.ts"