opencode-raven 2.2.1 → 2.3.0

package/index.ts

@@ -1,2444 +1,14 @@
-import type { Plugin, PluginInput } from "@opencode-ai/plugin"
-import { tool } from "@opencode-ai/plugin"
-import { Client } from "@modelcontextprotocol/sdk/client/index.js"
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js"
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js"
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
-import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, rmSync } from "node:fs"
-import { join } from "node:path"
-import { homedir, tmpdir } from "node:os"
-
-// ── Resolve paths relative to this package (works in node_modules/) ──
-const PKG_DIR = import.meta.dirname!
-
-const RAVEN_MD = join(PKG_DIR, "Raven.md")
-const RAVEN_MCP_MD = join(PKG_DIR, "RavenMcp.md")
-const MCP_GUIDANCE_MD = join(PKG_DIR, "mcp-guidance.md")
-const PACKAGE_JSON = JSON.parse(readFileSync(join(PKG_DIR, "package.json"), "utf-8"))
-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",
-  "websearch",
-  "bash",
-]
-
-const DEFAULT_ROUTE_TOOL_KEYWORDS: string[] = []
-
-const DEFAULT_ON_DEMAND_MCP_SERVERS: Record<string, OnDemandMcpServer> = {
-  context7: {
-    enabled: true,
-    type: "remote",
-    url: "https://mcp.context7.com/mcp",
-    description: "Library/framework documentation lookup.",
-  },
-  exa: {
-    enabled: true,
-    type: "remote",
-    url: "https://mcp.exa.ai/mcp",
-    description: "Live web search and webpage fetching.",
-  },
-  grep_app: {
-    enabled: true,
-    type: "remote",
-    url: "https://mcp.grep.app",
-    description: "Public GitHub code search and real-world examples.",
-  },
-}
-
-const DEFAULT_ON_DEMAND_MCP_METADATA: Record<string, OnDemandMcpMetadata> = {
-  context7: {
-    autoGeneratedDescription: "Finds current library, framework, SDK, package, and API documentation; useful for implementation, configuration, and debugging with version-specific docs.",
-  },
-  exa: {
-    autoGeneratedDescription: "Searches the live web, fetches webpages, researches companies/products, and gathers current information from online sources.",
-  },
-  grep_app: {
-    autoGeneratedDescription: "Searches public GitHub repositories for real-world code examples, usage patterns, configuration snippets, and implementation references.",
-  },
-}
-
-const NEVER_ROUTE_TOOLS = new Set(["raven_seek", "raven_mcp", "raven_mcp_bridge", "task", "subtask"])
-const MAX_TIMER_MS = 2_147_483_647
-const MAX_TIMEOUT_SECONDS = Math.floor(MAX_TIMER_MS / 1000)
-
-// ── 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
-
-// Strip quoted content to avoid false positives (e.g. echo "use grep here")
-function stripHeredocs(cmd: string): string {
-  return cmd.replace(/<<-?\s*["']?(\w+)["']?[\s\S]*?\n\s*\1/g, "")
-}
-
-function stripShellComments(cmd: string): string {
-  return cmd
-    .split("\n")
-    .map((line) => line.replace(/(^|\s)#.*$/, "$1").trimEnd())
-    .join("\n")
-}
-
-function stripQuotedContent(cmd: string): string {
-  return stripShellComments(stripHeredocs(cmd)
-    .replace(/'[^']*'/g, "''")
-    .replace(/"[^"]*"/g, '""'))
-}
-
-function unquoteShellPayload(value: string): string {
-  const payload = value.trim()
-  const quote = payload[0]
-  return (quote === '"' || quote === "'") && payload.endsWith(quote)
-    ? payload.slice(1, -1)
-    : payload
-}
-
-function wrappedShellPayload(cmd: string): string | undefined {
-  const command = stripShellComments(stripHeredocs(cmd)).trim()
-  const match = command.match(/^(?:"([^"]+)"|'([^']+)'|(\S+))(?:\s+([\s\S]+))?$/)
-  if (!match) return undefined
-
-  const executable = (match[1] ?? match[2] ?? match[3]).replace(/\\/g, "/").split("/").pop()?.toLowerCase()
-  const rest = match[4] ?? ""
-  if (executable === "cmd" || executable === "cmd.exe") {
-    const payload = rest.match(/^(?:\/[dqs]\s+)*\/c\s+([\s\S]+)$/i)?.[1]
-    return payload === undefined ? undefined : unquoteShellPayload(payload)
-  }
-
-  if (["sh", "sh.exe", "bash", "bash.exe", "zsh", "zsh.exe", "dash", "dash.exe"].includes(executable ?? "")) {
-    const payload = rest.match(/^-[a-z]*c\s+([\s\S]+)$/i)?.[1]
-    return payload === undefined ? undefined : unquoteShellPayload(payload)
-  }
-
-  if (["powershell", "powershell.exe", "pwsh", "pwsh.exe"].includes(executable ?? "")) {
-    const payload = rest.match(/(?:^|\s)-(?:command|c)\s+([\s\S]+)$/i)?.[1]
-    if (payload === undefined) return undefined
-    const unquoted = unquoteShellPayload(payload)
-    return unquoted.replace(
-      /(^|(?:(?:&&|\|\||[;|\n{(])\s*))&\s+(?:"([^"]+)"|'([^']+)'|(\S+))/g,
-      (_match, prefix, doubleQuoted, singleQuoted, bare) => `${prefix}${doubleQuoted ?? singleQuoted ?? bare}`,
-    )
-  }
-
-  return undefined
-}
-
-function splitPipelineSegments(cmd: string): string[] {
-  const segments: string[] = []
-  let current = ""
-  for (let i = 0; i < cmd.length; i++) {
-    const char = cmd[i]
-    const prev = cmd[i - 1]
-    const next = cmd[i + 1]
-    if (char === "|" && prev !== "|" && next !== "|") {
-      segments.push(current)
-      current = ""
-    } else {
-      current += char
-    }
-  }
-  segments.push(current)
-  return segments
-}
-
-function isOutputFilterSegment(segment: string): boolean {
-  return /^\s*(?:grep|ripgrep|rg|egrep|fgrep|findstr|Select-String|head|tail)\b/i.test(segment)
-}
-
-function hasSearchAfterCommandSeparator(segment: string): boolean {
-  const separator = segment.search(/;|&&|\|\|/)
-  return separator !== -1 && SEARCH_BASH_RE.test(segment.slice(separator))
-}
-
-function commandLooksLikeSearch(cmd: string): boolean {
-  const wrapped = wrappedShellPayload(cmd)
-  if (wrapped !== undefined) return commandLooksLikeSearch(wrapped)
-
-  const stripped = stripQuotedContent(cmd)
-  const lower = stripped.toLowerCase().trim()
-  if (/^cmd\s+\/c\s+"?(?:findstr|find|tree)\b/.test(lower)) return true
-  if (/^cmd\s+\/c\s+"?dir\b[^\n]*\s\/s\b/.test(lower)) return true
-
-  return splitPipelineSegments(stripped).some((segment, index) => {
-    // Allow bounded filters over output already produced by the previous command:
-    //   pacman -Qi libarchive | head -15
-    //   7z i | grep -i udf
-    // These are not Raven-worthy filesystem/web/doc searches.
-    if (index > 0 && isOutputFilterSegment(segment)) return hasSearchAfterCommandSeparator(segment)
-    return SEARCH_BASH_RE.test(segment)
-  })
-}
-
-function isSearchBash(tool: string, args: any): boolean {
-  if (tool !== "bash") return false
-  return commandLooksLikeSearch(String(args?.command ?? ""))
-}
-
-// ── Config file shape ──
-interface OnDemandMcpToolInfo {
-  name: string
-  description?: string
-}
-
-interface BaseOnDemandMcpServer {
-  enabled?: boolean
-  timeout?: number
-  description?: string
-}
-
-interface OnDemandMcpMetadata {
-  autoGeneratedDescription?: string
-  autoGeneratedTools?: OnDemandMcpToolInfo[]
-  avoidedSchemaBytes?: number
-  status?: "pending" | "ready" | "failed"
-  lastError?: string
-  lastCheckedAt?: string
-}
-
-interface RemoteOnDemandMcpServer extends BaseOnDemandMcpServer {
-  type: "remote"
-  url: string
-  headers?: Record<string, string>
-}
-
-interface LocalOnDemandMcpServer extends BaseOnDemandMcpServer {
-  type: "local"
-  command: string[]
-  environment?: Record<string, string>
-  cwd?: string
-}
-
-type OnDemandMcpServer = RemoteOnDemandMcpServer | LocalOnDemandMcpServer
-type OnDemandMcpDescriptionDetail = "full" | "minimized"
-type RavenMcpOperation = "list_tools" | "call_tool" | "list_resources" | "read_resource" | "list_prompts" | "get_prompt"
-
-interface RavenSeekConfig {
-  model?: string
-  reasoning_effort?: string
-  instructions?: string
-  routeTools?: string[]
-  routeToolKeywords?: string[]
-  excludeAgents?: string[]
-  excludeTools?: string[]
-  timeout?: number
-}
-
-interface RavenMcpConfig {
-  model?: string
-  reasoning_effort?: string
-  instructions?: string
-  timeout?: number
-  descriptionDetail?: OnDemandMcpDescriptionDetail
-  onDemandMcpServers?: Record<string, OnDemandMcpServer>
-}
-
-interface RavenConfig {
-  raven_seek: RavenSeekConfig
-  raven_mcp: RavenMcpConfig
-  stats?: { bytes: number }
-}
-
-// ── Parse Raven.md frontmatter ──
-const ravenMd = readFileSync(RAVEN_MD, "utf-8")
-const { frontmatter: fm, prompt: ravenPrompt } = parseRavenMd(ravenMd)
-const ravenMcpMd = readFileSync(RAVEN_MCP_MD, "utf-8")
-const { frontmatter: mcpFm, prompt: ravenMcpPrompt } = parseRavenMd(ravenMcpMd)
-
-const DEFAULT_CONFIG: RavenConfig = {
-  raven_seek: {
-    model: fm.model,
-    reasoning_effort: fm.reasoning_effort,
-    instructions: "",
-    routeTools: DEFAULT_ROUTE_TOOLS,
-    routeToolKeywords: DEFAULT_ROUTE_TOOL_KEYWORDS,
-    excludeAgents: [],
-    excludeTools: [],
-    timeout: 600,
-  },
-  raven_mcp: {
-    model: mcpFm.model,
-    reasoning_effort: mcpFm.reasoning_effort,
-    instructions: "",
-    timeout: 600,
-    descriptionDetail: "full",
-    onDemandMcpServers: DEFAULT_ON_DEMAND_MCP_SERVERS,
+import type { Plugin as V1Plugin } from "@opencode-ai/plugin"
+import type { Plugin as V2Plugin } from "@opencode/plugin"
+import createRavenRuntime from "./raven-core"
+
+// Object entrypoints are supported by OpenCode 1.18.29+. Each host selects its
+// own lifecycle; the v2 SDK is never loaded by a v1 installation.
+export default {
+  id: "opencode-raven",
+  server: (async (input) => createRavenRuntime(input)) satisfies V1Plugin,
+  async setup(context) {
+    const { setupRaven } = await import("./v2")
+    return setupRaven(context)
   },
-}
-
-function parseRavenMd(raw: string): { frontmatter: Record<string, any>; prompt: string } {
-  const parts = raw.split("---")
-  if (parts.length < 3) {
-    throw new Error("Raven.md missing frontmatter (--- delimiters)")
-  }
-  return { frontmatter: parseYaml(parts[1]), prompt: parts.slice(2).join("---").trim() }
-}
-
-// ── Minimal YAML parser (handles the structure used in Raven.md) ──
-function parseYaml(yaml: string): Record<string, any> {
-  const lines = yaml.split("\n")
-  const root: Record<string, any> = {}
-  const stack: Array<{ obj: Record<string, any>; indent: number }> = [
-    { obj: root, indent: -1 },
-  ]
-
-  for (const rawLine of lines) {
-    const line = rawLine.trimEnd()
-    if (!line.trim() || line.trim().startsWith("#")) continue
-
-    const indent = line.search(/\S/)
-    const colonIdx = line.indexOf(":")
-    if (colonIdx === -1) continue
-
-    const rawKey = line.slice(indent, colonIdx).trim()
-    const key =
-      (rawKey.startsWith('"') && rawKey.endsWith('"')) ||
-      (rawKey.startsWith("'") && rawKey.endsWith("'"))
-        ? rawKey.slice(1, -1)
-        : rawKey
-
-    const rawValue = line.slice(colonIdx + 1).trim()
-
-    while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
-      stack.pop()
-    }
-    const current = stack[stack.length - 1].obj
-
-    if (!rawValue) {
-      const nested: Record<string, any> = {}
-      current[key] = nested
-      stack.push({ obj: nested, indent })
-    } else {
-      let value: any = rawValue
-      if (
-        (value.startsWith('"') && value.endsWith('"')) ||
-        (value.startsWith("'") && value.endsWith("'"))
-      ) {
-        value = value.slice(1, -1)
-      } else if (value === "true") {
-        value = true
-      } else if (value === "false") {
-        value = false
-      } else if (/^\d+$/.test(value)) {
-        value = parseInt(value, 10)
-      }
-      current[key] = value
-    }
-  }
-
-  return root
-}
-
-// ── Move unknown frontmatter fields into options ──
-const KNOWN_KEYS = new Set([
-  "description", "mode", "hidden", "model", "permission",
-  "prompt", "name", "color", "steps", "disable",
-  "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()))]
-}
-
-function cloneOnDemandMcpServers(value: Record<string, OnDemandMcpServer>): Record<string, OnDemandMcpServer> {
-  return JSON.parse(JSON.stringify(value))
-}
-
-function cloneOnDemandMcpMetadata(value: Record<string, OnDemandMcpMetadata>): Record<string, OnDemandMcpMetadata> {
-  return JSON.parse(JSON.stringify(value))
-}
-
-function normalizeToolInfo(value: unknown): OnDemandMcpToolInfo[] | undefined {
-  if (!Array.isArray(value)) return undefined
-  const tools = value
-    .filter((item) => item && typeof item === "object" && typeof item.name === "string" && item.name.trim())
-    .map((item) => ({
-      name: item.name.trim(),
-      ...(typeof item.description === "string" && item.description.trim() ? { description: item.description.trim() } : {}),
-    }))
-  return tools.length ? tools : undefined
-}
-
-function normalizeStringRecord(value: unknown): Record<string, string> | undefined {
-  if (!value || typeof value !== "object") return undefined
-  const entries = Object.entries(value).filter((entry): entry is [string, string] => typeof entry[1] === "string")
-  return entries.length ? Object.fromEntries(entries) : undefined
-}
-
-function normalizeOnDemandMcpServer(value: unknown): OnDemandMcpServer | undefined {
-  if (!value || typeof value !== "object") return undefined
-  const source = value as Record<string, any>
-  const base = {
-    enabled: source.enabled !== false,
-    ...(typeof source.timeout === "number" && Number.isFinite(source.timeout) && source.timeout >= 1 && source.timeout <= MAX_TIMER_MS
-      ? { timeout: Math.floor(source.timeout) }
-      : {}),
-    ...(typeof source.description === "string" && source.description.trim() ? { description: source.description.trim() } : {}),
-  }
-
-  if (source.type === "local") {
-    const commandParts = Array.isArray(source.command)
-      ? source.command.filter((arg: unknown): arg is string => typeof arg === "string" && !!arg.trim())
-      : []
-    if (!commandParts.length) return undefined
-    const environment = normalizeStringRecord(source.environment)
-    return {
-      ...base,
-      type: "local",
-      command: commandParts,
-      ...(environment ? { environment } : {}),
-      ...(typeof source.cwd === "string" && source.cwd.trim() ? { cwd: source.cwd.trim() } : {}),
-    }
-  }
-
-  if (source.type === "remote" || typeof source.url === "string") {
-    if (typeof source.url !== "string" || !source.url.trim()) return undefined
-    const headers = normalizeStringRecord(source.headers)
-    return {
-      ...base,
-      type: "remote",
-      url: source.url.trim(),
-      ...(headers ? { headers } : {}),
-    }
-  }
-
-  return undefined
-}
-
-function normalizeOnDemandMcpMetadata(value: unknown, fallback: Record<string, OnDemandMcpMetadata> = {}): Record<string, OnDemandMcpMetadata> {
-  const source = value && typeof value === "object" ? value as Record<string, any> : fallback
-  const result: Record<string, OnDemandMcpMetadata> = {}
-  for (const [key, raw] of Object.entries(source)) {
-    if (!key.trim() || !raw || typeof raw !== "object") continue
-    const item = raw as Record<string, unknown>
-    const metadata: OnDemandMcpMetadata = {}
-    if (typeof item.autoGeneratedDescription === "string" && item.autoGeneratedDescription.trim()) {
-      metadata.autoGeneratedDescription = item.autoGeneratedDescription.trim()
-    }
-    const tools = normalizeToolInfo(item.autoGeneratedTools)
-    if (tools) metadata.autoGeneratedTools = tools
-    if (typeof item.avoidedSchemaBytes === "number" && Number.isFinite(item.avoidedSchemaBytes) && item.avoidedSchemaBytes >= 0) {
-      metadata.avoidedSchemaBytes = Math.round(item.avoidedSchemaBytes)
-    }
-    if (item.status === "pending" || item.status === "ready" || item.status === "failed") metadata.status = item.status
-    if (typeof item.lastError === "string" && item.lastError.trim()) metadata.lastError = item.lastError.trim()
-    if (typeof item.lastCheckedAt === "string" && item.lastCheckedAt.trim()) metadata.lastCheckedAt = item.lastCheckedAt.trim()
-    if (metadata.autoGeneratedDescription || metadata.autoGeneratedTools?.length || metadata.avoidedSchemaBytes || metadata.status || metadata.lastError || metadata.lastCheckedAt) result[key.trim()] = metadata
-  }
-  return result
-}
-
-function normalizeOnDemandMcpServers(value: unknown, fallback: Record<string, OnDemandMcpServer> = {}): Record<string, OnDemandMcpServer> {
-  const source = value && typeof value === "object" ? value as Record<string, unknown> : fallback
-  const result: Record<string, OnDemandMcpServer> = {}
-  for (const [key, raw] of Object.entries(source)) {
-    if (!key.trim()) continue
-    const server = normalizeOnDemandMcpServer(raw)
-    if (server) result[key.trim()] = server
-  }
-  return result
-}
-
-// ── Plugin ──
-export default (async (input: PluginInput) => {
-  const client = input.client
-
-  // Raven state lives under the global opencode config directory.
-  const opencodeConfigDir = join(homedir(), ".config", "opencode")
-  const ravenConfigDir = join(opencodeConfigDir, "opencode-raven")
-  const configFile = join(ravenConfigDir, "raven-config.json")
-  const mcpMetadataFile = join(ravenConfigDir, "autogenerated-on-demand-mcp-metadata.json")
-  const dynamicGuidanceFile = join(ravenConfigDir, "autogenerated-on-demand-guidance.md")
-
-  function normalizeConfig(raw: any): RavenConfig {
-    const source = raw && typeof raw === "object" ? raw : {}
-    const seekSource = source.raven_seek && typeof source.raven_seek === "object" ? source.raven_seek : source
-    const mcpSource = source.raven_mcp && typeof source.raven_mcp === "object" ? source.raven_mcp : source
-    const legacyInstructions = typeof source.ravenInstructions === "string" ? source.ravenInstructions : undefined
-    const normalized: RavenConfig = {
-      raven_seek: {
-        model: typeof seekSource.model === "string" ? seekSource.model : DEFAULT_CONFIG.raven_seek.model,
-        reasoning_effort: typeof seekSource.reasoning_effort === "string" ? seekSource.reasoning_effort : DEFAULT_CONFIG.raven_seek.reasoning_effort,
-        instructions: typeof seekSource.instructions === "string" ? seekSource.instructions : legacyInstructions ?? "",
-        routeTools: uniqueStrings(seekSource.routeTools, DEFAULT_ROUTE_TOOLS),
-        routeToolKeywords: uniqueStrings(seekSource.routeToolKeywords, DEFAULT_ROUTE_TOOL_KEYWORDS),
-        excludeAgents: uniqueStrings(seekSource.excludeAgents),
-        excludeTools: uniqueStrings(seekSource.excludeTools),
-        timeout: typeof seekSource.timeout === "number" && Number.isFinite(seekSource.timeout)
-          && seekSource.timeout >= 10 && seekSource.timeout <= MAX_TIMEOUT_SECONDS
-          ? Math.floor(seekSource.timeout)
-          : DEFAULT_CONFIG.raven_seek.timeout,
-      },
-      raven_mcp: {
-        model: typeof mcpSource.model === "string" ? mcpSource.model : DEFAULT_CONFIG.raven_mcp.model,
-        reasoning_effort: typeof mcpSource.reasoning_effort === "string" ? mcpSource.reasoning_effort : DEFAULT_CONFIG.raven_mcp.reasoning_effort,
-        instructions: typeof mcpSource.instructions === "string" ? mcpSource.instructions : legacyInstructions ?? "",
-        timeout: typeof mcpSource.timeout === "number" && Number.isFinite(mcpSource.timeout)
-          && mcpSource.timeout >= 10 && mcpSource.timeout <= MAX_TIMEOUT_SECONDS
-          ? Math.floor(mcpSource.timeout)
-          : DEFAULT_CONFIG.raven_mcp.timeout,
-        descriptionDetail: mcpSource.descriptionDetail === "minimized"
-          ? "minimized"
-          : mcpSource.descriptionDetail === "full"
-            ? "full"
-            : source.onDemandMcpDescriptionDetail === "minimized" ? "minimized" : "full",
-        onDemandMcpServers: mcpSource.onDemandMcpServers === undefined
-          ? cloneOnDemandMcpServers(DEFAULT_ON_DEMAND_MCP_SERVERS)
-          : normalizeOnDemandMcpServers(mcpSource.onDemandMcpServers),
-      },
-    }
-    normalized.stats = source.stats && typeof source.stats === "object"
-      && typeof source.stats.bytes === "number" && Number.isFinite(source.stats.bytes) && source.stats.bytes >= 0
-      ? { bytes: Math.round(source.stats.bytes) }
-      : undefined
-
-    return normalized
-  }
-
-  function loadConfig(): RavenConfig {
-    if (existsSync(configFile)) {
-      try {
-        const raw = JSON.parse(readFileSync(configFile, "utf-8"))
-        const normalized = normalizeConfig(raw)
-        if (!raw.raven_seek || !raw.raven_mcp) writeConfig(normalized)
-        return normalized
-      } catch {
-        // Preserve malformed or partially-written config so the user can repair it.
-        return { ...DEFAULT_CONFIG }
-      }
-    }
-    // Auto-create config file with defaults on first run
-    writeConfig(DEFAULT_CONFIG)
-    return { ...DEFAULT_CONFIG }
-  }
-
-  function writeConfig(config: RavenConfig) {
-    try {
-      mkdirSync(ravenConfigDir, { recursive: true })
-      writeFileSync(configFile, JSON.stringify(config, null, 2) + "\n")
-    } catch { /* non-fatal: config changes remain in-session */ }
-  }
-
-  function loadMcpMetadata(): Record<string, OnDemandMcpMetadata> {
-    const defaults = cloneOnDemandMcpMetadata(DEFAULT_ON_DEMAND_MCP_METADATA)
-    try {
-      if (existsSync(mcpMetadataFile)) {
-        return { ...defaults, ...normalizeOnDemandMcpMetadata(JSON.parse(readFileSync(mcpMetadataFile, "utf-8"))) }
-      }
-    } catch { /* ignore corruption, use defaults */ }
-    saveMcpMetadata(defaults)
-    return defaults
-  }
-
-  function saveMcpMetadata(metadata: Record<string, OnDemandMcpMetadata>) {
-    try {
-      mkdirSync(ravenConfigDir, { recursive: true })
-      writeFileSync(mcpMetadataFile, JSON.stringify(metadata, null, 2) + "\n")
-    } catch { /* non-fatal: generated metadata can be refreshed */ }
-  }
-
-  function saveDynamicGuidance() {
-    try {
-      mkdirSync(ravenConfigDir, { recursive: true })
-      writeFileSync(dynamicGuidanceFile, `## Raven on-demand MCP capabilities\n\n${onDemandMcpGuidance("delegate", dynamicGuidanceMcpOrder())}\n`, "utf-8")
-    } catch { /* non-fatal: guidance still exists in tool/subagent paths */ }
-  }
-
-  let config = loadConfig()
-
-  function updateConfig(update: Partial<RavenConfig> | ((latest: RavenConfig) => Partial<RavenConfig>)): RavenConfig {
-    try {
-      const raw = existsSync(configFile) ? JSON.parse(readFileSync(configFile, "utf-8")) : config
-      const latest = normalizeConfig(raw)
-      const patch = typeof update === "function" ? update(latest) : update
-      config = normalizeConfig({
-        ...latest,
-        ...patch,
-        raven_seek: { ...latest.raven_seek, ...patch.raven_seek },
-        raven_mcp: { ...latest.raven_mcp, ...patch.raven_mcp },
-      })
-      writeConfig(config)
-    } catch {
-      // Keep malformed or partially-written external edits intact instead of replacing them.
-      const patch = typeof update === "function" ? update(config) : update
-      config = normalizeConfig({
-        ...config,
-        ...patch,
-        raven_seek: { ...config.raven_seek, ...patch.raven_seek },
-        raven_mcp: { ...config.raven_mcp, ...patch.raven_mcp },
-      })
-    }
-    return config
-  }
-  let mcpMetadata = loadMcpMetadata()
-  type DelegationKind = "seek" | "mcp"
-  const ravenSessions = new Set<string>()
-  const ravenSessionKinds = new Map<string, DelegationKind>()
-  const activeRavenPrompts = new Set<string>()
-  const ravenTaskCalls = new Set<string>()
-  const sessionAgents = new Map<string, string>()
-  const ravenSessionParents = new Map<string, string>()
-  const ravenErrorWaiters = new Map<string, (error: Error) => void>()
-  const ravenProgressWaiters = new Map<string, () => void>()
-  let globalMcpServers: string[] = []
-  let duplicateMcpServers: string[] = []
-  let updateInfo: { current: string; latest?: string; available: boolean } | undefined
-  let updateCheckPromise: Promise<{ current: string; latest?: string; available: boolean }> | undefined
-  let updateToastPending = false
-  let mcpFailureToastPending = false
-  let duplicateMcpToastPending = false
-  let mcpRefreshScheduled = false
-  let mcpRefreshPromise: Promise<{ refreshed: string[]; failed: string[] }> | undefined
-  let mcpRefreshQueue: Promise<unknown> = Promise.resolve()
-  const mcpRefreshControllers = new Set<AbortController>()
-  let lastNotifiedMcpFailureKey = ""
-  const ravenProviderIssues: Partial<Record<DelegationKind, string>> = {}
-
-  // Replace generated instructions from older releases before OpenCode consumes them.
-  saveDynamicGuidance()
-  resetOnDemandMcpRuntimeStatuses()
-
-  function resetOnDemandMcpRuntimeStatuses() {
-    let changed = false
-    for (const [name] of activeOnDemandMcpEntries()) {
-      const metadata = mcpMetadata[name] ?? {}
-      if (metadata.status !== "pending" || metadata.lastError || metadata.lastCheckedAt) {
-        mcpMetadata[name] = { ...metadata, status: "pending" }
-        delete mcpMetadata[name].lastError
-        delete mcpMetadata[name].lastCheckedAt
-        changed = true
-      }
-    }
-    if (changed) saveMcpMetadata(mcpMetadata)
-  }
-
-  // ── Check if an agent is excluded from Raven enforcement (case-insensitive) ──
-  function isExcluded(agent: string | undefined): boolean {
-    if (!agent || !config.raven_seek.excludeAgents?.length) return false
-    const lower = agent.toLowerCase()
-    return config.raven_seek.excludeAgents.some((a) => a.toLowerCase() === lower)
-  }
-
-  function isRouteConfigured(toolName: string): boolean {
-    const tool = toolName.toLowerCase()
-    if (NEVER_ROUTE_TOOLS.has(tool)) return false
-    if (config.raven_seek.routeTools?.some((name) => name.toLowerCase() === tool)) return true
-    if (config.raven_seek.routeToolKeywords?.some((keyword) => tool.includes(keyword.toLowerCase()))) return true
-    return globalMcpServers.some((server) => tool.startsWith(`${server.toLowerCase()}_`))
-  }
-
-  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 {
-    if (ravenProviderIssues.seek) {
-      return `Raven search is currently unavailable: ${ravenProviderIssues.seek}
-
-${ravenRecoveryInstructions("seek")}`
-    }
-    return `The '${tool}' tool call is blocked by Raven. Your next tool call should be raven_seek(query="${attemptedQuery(tool, args).replace(/"/g, "'")}").`
-  }
-
-  function ravenRecoveryInstructions(kind: DelegationKind): string {
-    const command = kind === "mcp" ? "/raven mcp model <provider/model>" : "/raven seek model <provider/model>"
-    return `Stop trying Raven-routed tools or MCPs for this request. Inform the user that Raven cannot run until its model/provider is changed or fixed.
-
-Tell the user to switch Raven's model with:
-  ${command}
-
-Example:
-  ${command.replace("<provider/model>", "openai/gpt-5.5")}
-
-Then restart opencode for the model change to take effect. If the task can be completed without Raven, continue without routed tools and clearly mention what could not be checked.`
-  }
-
-  function routeSummary(): string {
-    const tools = config.raven_seek.routeTools?.length ? config.raven_seek.routeTools.join(", ") : "(none)"
-    const mcps = globalMcpServers.length ? `${globalMcpServers.join(", ")} (auto-detected)` : "none detected"
-    const keywords = config.raven_seek.routeToolKeywords?.length ? config.raven_seek.routeToolKeywords.join(", ") : "(none)"
-    const duplicates = duplicateMcpServers.length ? `\n  Duplicate MCP config: ${duplicateMcpServers.join(", ")} (configured globally and on-demand)` : ""
-    return `Raven routing:\n  Routed tools: ${tools}\n  Routed global MCPs: ${mcps}\n  Routed tool keywords: ${keywords}${duplicates}`
-  }
-
-  function mcpSummary(): string {
-    const buckets = onDemandMcpStatusBuckets()
-    const total = buckets.loaded.length + buckets.failed.length + buckets.pending.length
-    if (!total) return `Raven on-demand MCPs (always behind Raven): none configured.\n  Guidance detail: ${config.raven_mcp.descriptionDetail ?? "full"}`
-    const lines = [
-      "Raven on-demand MCPs (always behind Raven):",
-      `  Loaded: ${buckets.loaded.length ? buckets.loaded.join(", ") : "none"}`,
-      `  Failed: ${buckets.failed.length ? buckets.failed.join(", ") : "none"}`,
-      `  Pending: ${buckets.pending.length ? buckets.pending.join(", ") : "none"}`,
-      `  Guidance detail: ${config.raven_mcp.descriptionDetail ?? "full"}`,
-    ]
-    return lines.join("\n")
-  }
-
-  function ravenAgentPrompt(): string {
-    const extra = config.raven_seek.instructions?.trim()
-    const prompt = ravenPrompt
-    return extra ? `${prompt}\n\nAdditional user instructions:\n${extra}` : prompt
-  }
-
-  function ravenMcpAgentPrompt(): string {
-    const extra = config.raven_mcp.instructions?.trim()
-    const onDemand = onDemandMcpGuidance("raven")
-    const prompt = `${ravenMcpPrompt}\n\nOn-demand MCP guidance:\n${onDemand}`
-    return extra ? `${prompt}\n\nAdditional user instructions:\n${extra}` : prompt
-  }
-
-  function compactText(value: unknown): string {
-    return String(value ?? "").replace(/\s+/g, " ").trim()
-  }
-
-  function truncateText(value: unknown, max = 240): string {
-    const text = compactText(value)
-    return text.length > max ? `${text.slice(0, Math.max(0, max - 3))}...` : text
-  }
-
-  function dynamicGuidanceMcpOrder(): string[] | undefined {
-    try {
-      if (!existsSync(dynamicGuidanceFile)) return undefined
-      const names: string[] = []
-      for (const line of readFileSync(dynamicGuidanceFile, "utf-8").split("\n")) {
-        const name = line.match(/^-\s+([^:]+):/)?.[1]?.trim()
-        if (name && !names.includes(name)) names.push(name)
-      }
-      return names
-    } catch {
-      return undefined
-    }
-  }
-
-  function orderedOnDemandMcpEntries(entries: [string, OnDemandMcpServer][], preferredOrder?: string[]): [string, OnDemandMcpServer][] {
-    if (!preferredOrder?.length) return entries
-    const order = new Map(preferredOrder.map((name, index) => [name.toLowerCase(), index]))
-    const existing = entries
-      .filter(([name]) => order.has(name.toLowerCase()))
-      .sort(([left], [right]) => order.get(left.toLowerCase())! - order.get(right.toLowerCase())!)
-    const added = entries.filter(([name]) => !order.has(name.toLowerCase()))
-    return [...existing, ...added]
-  }
-
-  function firstSentenceText(value: unknown): string {
-    const text = compactText(value)
-    const period = text.indexOf(".")
-    return period === -1 ? text : text.slice(0, period + 1)
-  }
-
-  function onDemandMcpGuidance(target: "delegate" | "raven" = "delegate", preferredOrder?: string[]): string {
-    const servers = config.raven_mcp.onDemandMcpServers ?? {}
-    const activeEntries = activeOnDemandMcpEntries()
-    const entries = orderedOnDemandMcpEntries(
-      target === "raven"
-        ? activeEntries
-        : activeEntries.filter(([name]) => onDemandMcpRuntimeStatus(name) === "ready"),
-      preferredOrder,
-    )
-    if (!Object.keys(servers).length) return "No on-demand MCPs are configured."
-    if (!activeEntries.length) return "No enabled on-demand MCPs are configured."
-    if (!entries.length) return "No loaded on-demand MCPs are available."
-
-    const detail = config.raven_mcp.descriptionDetail ?? "full"
-    const lines = entries.map(([name, server]) => {
-      const metadata = mcpMetadata[name] ?? {}
-      const userDescription = firstSentenceText(server.description)
-      const generated = firstSentenceText(metadata.autoGeneratedDescription)
-      const parts = [userDescription, generated ? `Discovered capabilities: ${generated}` : ""].filter(Boolean)
-      const summary = parts.length ? parts.join(" ") : "Description discovery pending."
-      if (detail === "minimized" || !metadata.autoGeneratedTools?.length) return `- ${name}: ${summary}`
-      const tools = metadata.autoGeneratedTools
-        .map((item) => `${item.name}${item.description ? ` - ${firstSentenceText(item.description)}` : ""}`)
-        .join("; ")
-      return `- ${name}: ${summary} Tools: ${tools}`
-    })
-    if (target === "raven") {
-      return `Use raven_mcp_bridge for these on-demand MCP capabilities:\n${lines.join("\n")}`
-    }
-    return `Non-Raven agents can use these on-demand MCP capabilities through the public raven_mcp delegator. Use raven_mcp for matching requests and include the target MCP server and likely capability when obvious. The raven-mcp agent itself must call raven_mcp_bridge directly instead:\n${lines.join("\n")}`
-  }
-
-  function resolveEnvPlaceholders(value: string): string {
-    return value.replace(/\{env:([A-Za-z_][A-Za-z0-9_]*)\}/g, (_match, name) => {
-      const envValue = process.env[name]
-      if (envValue === undefined) throw new Error(`Missing environment variable ${name}`)
-      return envValue
-    })
-  }
-
-  function resolveStringRecord(value: Record<string, string> | undefined): Record<string, string> | undefined {
-    if (!value) return undefined
-    const result: Record<string, string> = {}
-    for (const [key, raw] of Object.entries(value)) {
-      result[key] = resolveEnvPlaceholders(raw)
-    }
-    return result
-  }
-
-  function cleanProcessEnv(): Record<string, string> {
-    const result: Record<string, string> = {}
-    for (const [key, value] of Object.entries(process.env)) {
-      if (typeof value === "string") result[key] = value
-    }
-    return result
-  }
-
-  function providerErrorMessage(error: any): string {
-    const name = String(error?.name ?? "")
-    const data = error?.data && typeof error.data === "object" ? error.data : {}
-    const status = typeof data.statusCode === "number" ? ` HTTP ${data.statusCode}.` : ""
-    const body = typeof data.responseBody === "string" && data.responseBody.trim() ? ` ${truncateText(data.responseBody, 500)}` : ""
-    const message = String(data.message ?? error?.message ?? error ?? "Unknown provider error")
-    return `Raven provider/API error${name ? ` (${name})` : ""}.${status} ${message}${body}`.trim()
-  }
-
-  function waitForRavenProviderError(sessionId: string): Promise<never> {
-    return new Promise((_resolve, reject) => {
-      ravenErrorWaiters.set(sessionId, reject)
-    })
-  }
-
-  function waitForRavenFirstProgress(sessionId: string, ms: number): Promise<never> {
-    return new Promise((_resolve, reject) => {
-      const timer = setTimeout(() => {
-        ravenProgressWaiters.delete(sessionId)
-        reject(new Error(`Raven did not produce an initial response within ${Math.round(ms / 1000)}s. If the Raven provider showed a retry dialog, this is likely an auth/quota/subscription issue. Check the Raven subagent/provider account, or retry after switching Raven to a working model.`))
-      }, ms)
-      ravenProgressWaiters.set(sessionId, () => {
-        clearTimeout(timer)
-        ravenProgressWaiters.delete(sessionId)
-      })
-    })
-  }
-
-  function reportRavenProviderError(sessionId: string, error: any) {
-    const waiter = ravenErrorWaiters.get(sessionId)
-    if (!waiter) return
-    waiter(new Error(providerErrorMessage(error)))
-  }
-
-  function reportRavenProgress(sessionId: string) {
-    ravenProgressWaiters.get(sessionId)?.()
-  }
-
-  function clearRavenWaiters(sessionId: string) {
-    ravenErrorWaiters.delete(sessionId)
-    ravenProgressWaiters.get(sessionId)?.()
-  }
-
-  type McpConnection = {
-    client: Client
-    transport: any
-    lastUsed: number
-    active: number
-  }
-
-  type McpConnectionAttempt = {
-    promise: Promise<McpConnection>
-    controller: AbortController
-    waiters: number
-  }
-
-  const mcpConnections = new Map<string, McpConnection>()
-  const mcpConnectionAttempts = new Map<string, McpConnectionAttempt>()
-  let mcpIdleTimer: ReturnType<typeof setInterval> | undefined
-
-  function mcpTimeoutMs(server: OnDemandMcpServer): number {
-    return server.timeout ?? (config.raven_mcp.timeout ?? 600) * 1000
-  }
-
-  async function closeMcpClient(client: Client, transport: any) {
-    try {
-      await transport?.close?.()
-    } catch { /* best-effort */ }
-    try {
-      await client.close()
-    } catch { /* best-effort */ }
-  }
-
-  async function connectMcpClient(client: Client, transport: any, timeout: number, label: string, signal?: AbortSignal) {
-    const controller = new AbortController()
-    let timedOut = false
-    const abort = () => controller.abort(signal?.reason)
-    if (signal?.aborted) abort()
-    else signal?.addEventListener("abort", abort, { once: true })
-    const timer = setTimeout(() => {
-      timedOut = true
-      controller.abort()
-    }, timeout)
-    const aborted = new Promise<never>((_resolve, reject) => {
-      const fail = () => reject(new Error(timedOut ? `${label} timed out after ${Math.round(timeout / 1000)}s` : `${label} cancelled`))
-      if (controller.signal.aborted) fail()
-      else controller.signal.addEventListener("abort", fail, { once: true })
-    })
-
-    try {
-      await Promise.race([
-        client.connect(transport, { signal: controller.signal, timeout }),
-        aborted,
-      ])
-    } catch (error) {
-      await closeMcpClient(client, transport)
-      throw error
-    } finally {
-      clearTimeout(timer)
-      signal?.removeEventListener("abort", abort)
-    }
-  }
-
-  async function closeMcpConnection(connection: McpConnection) {
-    await closeMcpClient(connection.client, connection.transport)
-  }
-
-  function stopMcpIdleTimerIfUnused() {
-    if (mcpConnections.size || mcpConnectionAttempts.size || !mcpIdleTimer) return
-    clearInterval(mcpIdleTimer)
-    mcpIdleTimer = undefined
-  }
-
-  function ensureMcpIdleTimer() {
-    if (mcpIdleTimer) return
-    mcpIdleTimer = setInterval(() => closeIdleMcpConnections(), 60_000)
-    ;(mcpIdleTimer as any).unref?.()
-  }
-
-  async function closeMcpConnectionKey(key: string, expected?: McpConnection) {
-    const existing = mcpConnections.get(key)
-    if (!existing || (expected && existing !== expected)) return
-    mcpConnections.delete(key)
-    await closeMcpConnection(existing)
-    stopMcpIdleTimerIfUnused()
-  }
-
-  function closeIdleMcpConnections(maxAgeMs = 10 * 60 * 1000) {
-    const now = Date.now()
-    for (const [key, connection] of mcpConnections) {
-      if (!connection.active && now - connection.lastUsed > maxAgeMs) {
-        void closeMcpConnectionKey(key, connection)
-      }
-    }
-  }
-
-  async function closeMcpConnectionsForSession(sessionId: string) {
-    const prefix = `${sessionId}:`
-    const pending: Promise<McpConnection>[] = []
-    for (const [key, attempt] of mcpConnectionAttempts) {
-      if (!key.startsWith(prefix)) continue
-      attempt.controller.abort()
-      pending.push(attempt.promise)
-    }
-    await Promise.allSettled(pending)
-    await Promise.all(
-      [...mcpConnections.keys()]
-        .filter((key) => key.startsWith(prefix))
-        .map((key) => closeMcpConnectionKey(key)),
-    )
-  }
-
-  function mcpConnectionKey(sessionId: string, serverName: string): string {
-    return `${sessionId}:${serverName.toLowerCase()}`
-  }
-
-  function getOnDemandMcpServer(serverName: string): [string, OnDemandMcpServer] | undefined {
-    const entries = activeOnDemandMcpEntries()
-    return entries.find(([name]) => name.toLowerCase() === serverName.toLowerCase())
-  }
-
-  function activeOnDemandMcpEntries(): [string, OnDemandMcpServer][] {
-    return Object.entries(config.raven_mcp.onDemandMcpServers ?? {}).filter(([, server]) => server.enabled !== false)
-  }
-
-  function waitForMcpConnection(attempt: McpConnectionAttempt, signal?: AbortSignal): Promise<McpConnection> {
-    if (!signal) {
-      attempt.waiters++
-      return attempt.promise.finally(() => attempt.waiters--)
-    }
-    if (signal.aborted) return Promise.reject(new Error("MCP request cancelled"))
-    attempt.waiters++
-    return new Promise((resolve, reject) => {
-      let settled = false
-      const finish = () => {
-        if (settled) return false
-        settled = true
-        attempt.waiters--
-        signal.removeEventListener("abort", abort)
-        return true
-      }
-      const abort = () => {
-        if (!finish()) return
-        if (!attempt.waiters) attempt.controller.abort(signal.reason)
-        reject(new Error("MCP request cancelled"))
-      }
-      signal.addEventListener("abort", abort, { once: true })
-      attempt.promise.then(
-        (connection) => { if (finish()) resolve(connection) },
-        (error) => { if (finish()) reject(error) },
-      )
-    })
-  }
-
-  async function connectOnDemandMcp(serverName: string, server: OnDemandMcpServer, signal?: AbortSignal): Promise<McpConnection> {
-    const timeout = mcpTimeoutMs(server)
-    const client = new Client({ name: PACKAGE_NAME, version: PACKAGE_VERSION })
-
-    if (server.type === "local") {
-      const env = { ...cleanProcessEnv(), ...resolveStringRecord(server.environment) }
-      const transport = new StdioClientTransport({
-        command: resolveEnvPlaceholders(server.command[0]),
-        args: server.command.slice(1).map((arg) => resolveEnvPlaceholders(arg)),
-        env,
-        stderr: "pipe",
-        cwd: server.cwd ? resolveEnvPlaceholders(server.cwd) : undefined,
-      })
-      transport.stderr?.on("data", () => {})
-      transport.stderr?.on("error", () => {})
-      await connectMcpClient(client, transport, timeout, `Connecting to ${serverName}`, signal)
-      return { client, transport, lastUsed: Date.now(), active: 0 }
-    }
-
-    const url = new URL(resolveEnvPlaceholders(server.url))
-    const headers = resolveStringRecord(server.headers)
-    const transport = new StreamableHTTPClientTransport(url, headers ? { requestInit: { headers } } : undefined)
-    try {
-      await connectMcpClient(client, transport, timeout, `Connecting to ${serverName}`, signal)
-      return { client, transport, lastUsed: Date.now(), active: 0 }
-    } catch (err) {
-      if (signal?.aborted) throw err
-      const fallbackClient = new Client({ name: PACKAGE_NAME, version: PACKAGE_VERSION })
-      const fallback = new SSEClientTransport(url, headers ? { requestInit: { headers } } : undefined)
-      try {
-        await connectMcpClient(fallbackClient, fallback, timeout, `Connecting to ${serverName} via SSE`, signal)
-        return { client: fallbackClient, transport: fallback, lastUsed: Date.now(), active: 0 }
-      } catch (fallbackError) {
-        throw fallbackError
-      }
-    }
-  }
-
-  async function getMcpConnection(sessionId: string, serverName: string, signal?: AbortSignal): Promise<McpConnection> {
-    if (signal?.aborted) throw new Error("MCP request cancelled")
-    closeIdleMcpConnections()
-    const match = getOnDemandMcpServer(serverName)
-    if (!match) throw new Error(`Unknown on-demand MCP server: ${serverName}`)
-    const [canonicalName, server] = match
-    const key = mcpConnectionKey(sessionId, canonicalName)
-    const existing = mcpConnections.get(key)
-    if (existing) {
-      existing.lastUsed = Date.now()
-      return existing
-    }
-
-    const pending = mcpConnectionAttempts.get(key)
-    if (pending && !pending.controller.signal.aborted) return waitForMcpConnection(pending, signal)
-    if (pending) mcpConnectionAttempts.delete(key)
-
-    const controller = new AbortController()
-    const attempt = { controller, waiters: 0 } as McpConnectionAttempt
-    attempt.promise = connectOnDemandMcp(canonicalName, server, controller.signal)
-      .then(async (connection) => {
-        if (controller.signal.aborted || mcpConnectionAttempts.get(key) !== attempt) {
-          await closeMcpConnection(connection)
-          throw new Error("MCP connection attempt cancelled")
-        }
-        mcpConnections.set(key, connection)
-        connection.client.onclose = () => {
-          if (mcpConnections.get(key) === connection) mcpConnections.delete(key)
-          stopMcpIdleTimerIfUnused()
-        }
-        ensureMcpIdleTimer()
-        return connection
-      })
-      .finally(() => {
-        if (mcpConnectionAttempts.get(key) === attempt) mcpConnectionAttempts.delete(key)
-        stopMcpIdleTimerIfUnused()
-      })
-    mcpConnectionAttempts.set(key, attempt)
-    ensureMcpIdleTimer()
-    return waitForMcpConnection(attempt, signal)
-  }
-
-  async function listAllMcpTools(client: Client, options?: { signal?: AbortSignal; timeout?: number }): Promise<any[]> {
-    const tools: any[] = []
-    let cursor: string | undefined
-    do {
-      const result: any = await client.listTools(cursor ? { cursor } : undefined as any, options)
-      tools.push(...(result.tools ?? []))
-      cursor = result.nextCursor
-    } while (cursor)
-    return tools
-  }
-
-  async function listAllMcpResources(client: Client, options?: { signal?: AbortSignal; timeout?: number }): Promise<any[]> {
-    const resources: any[] = []
-    let cursor: string | undefined
-    do {
-      const result: any = await client.listResources(cursor ? { cursor } : undefined as any, options)
-      resources.push(...(result.resources ?? []))
-      cursor = result.nextCursor
-    } while (cursor)
-    return resources
-  }
-
-  async function listAllMcpPrompts(client: Client, options?: { signal?: AbortSignal; timeout?: number }): Promise<any[]> {
-    const prompts: any[] = []
-    let cursor: string | undefined
-    do {
-      const result: any = await client.listPrompts(cursor ? { cursor } : undefined as any, options)
-      prompts.push(...(result.prompts ?? []))
-      cursor = result.nextCursor
-    } while (cursor)
-    return prompts
-  }
-
-  function generatedToolsFromMcpTools(tools: any[]): OnDemandMcpToolInfo[] {
-    return tools
-      .filter((item) => item?.name)
-      .map((item) => ({
-        name: String(item.name),
-        ...(item.description ? { description: compactText(item.description) } : {}),
-      }))
-  }
-
-  function estimateAvoidedMcpSchemaBytes(tools: any[]): number {
-    if (!tools.length) return 0
-    return JSON.stringify(tools).length
-  }
-
-  function synthesizeMcpDescription(serverName: string, tools: OnDemandMcpToolInfo[]): string {
-    if (!tools.length) return `${serverName} exposes on-demand MCP capabilities. Use list_tools for available operations.`
-    const descriptions = tools.map((item) => item.description || item.name).filter(Boolean)
-    const joined = descriptions.slice(0, 6).join("; ")
-    return compactText(`${serverName} provides on-demand MCP tools for ${joined}.`)
-  }
-
-  async function refreshOnDemandMcpDescriptions(force = false, serverName?: string, signal?: AbortSignal): Promise<{ refreshed: string[]; failed: string[] }> {
-    if (signal?.aborted) return { refreshed: [], failed: [] }
-    const entries = activeOnDemandMcpEntries()
-      .filter(([name]) => !serverName || name.toLowerCase() === serverName.toLowerCase())
-      .filter(([name]) => {
-        const metadata = mcpMetadata[name]
-        return force || metadata?.status === "pending" || metadata?.status === "failed" || !metadata?.autoGeneratedDescription || !metadata.autoGeneratedTools?.length || metadata.avoidedSchemaBytes === undefined
-      })
-    const refreshed: string[] = []
-    const failed: string[] = []
-    if (!entries.length) return { refreshed, failed }
-    let changed = false
-    for (const [name, server] of entries) {
-      if (signal?.aborted) break
-      let connection: McpConnection | undefined
-      const checkedAt = new Date().toISOString()
-      try {
-        connection = await connectOnDemandMcp(name, server, signal)
-        const rawTools = await listAllMcpTools(connection.client, { signal, timeout: mcpTimeoutMs(server) })
-        const tools = generatedToolsFromMcpTools(rawTools)
-        mcpMetadata[name] = {
-          autoGeneratedTools: tools,
-          autoGeneratedDescription: synthesizeMcpDescription(name, tools),
-          avoidedSchemaBytes: estimateAvoidedMcpSchemaBytes(rawTools),
-          status: "ready",
-          lastCheckedAt: checkedAt,
-        }
-        changed = true
-        refreshed.push(name)
-      } catch (err: any) {
-        if (signal?.aborted) break
-        mcpMetadata[name] = {
-          ...(mcpMetadata[name] ?? {}),
-          status: "failed",
-          lastError: truncateText(err?.message ?? err, 500),
-          lastCheckedAt: checkedAt,
-        }
-        changed = true
-        failed.push(name)
-        // Keep startup/discovery best-effort; /raven mcp exposes failures.
-      } finally {
-        if (connection) await closeMcpConnection(connection)
-      }
-    }
-    if (changed) {
-      saveMcpMetadata(mcpMetadata)
-      saveDynamicGuidance()
-    }
-    return { refreshed, failed }
-  }
-
-  function waitForRefreshDelay(ms: number, signal: AbortSignal): Promise<void> {
-    if (signal.aborted) return Promise.resolve()
-    return new Promise((resolve) => {
-      const timer = setTimeout(done, ms)
-      function done() {
-        clearTimeout(timer)
-        signal.removeEventListener("abort", done)
-        resolve()
-      }
-      signal.addEventListener("abort", done, { once: true })
-    })
-  }
-
-  function queueOnDemandMcpRefresh(force = false, serverName?: string, delay = 0): Promise<{ refreshed: string[]; failed: string[] }> {
-    const controller = new AbortController()
-    mcpRefreshControllers.add(controller)
-    const run = mcpRefreshQueue
-      .catch(() => undefined)
-      .then(async () => {
-        if (delay) await waitForRefreshDelay(delay, controller.signal)
-        return refreshOnDemandMcpDescriptions(force, serverName, controller.signal)
-      })
-      .finally(() => mcpRefreshControllers.delete(controller))
-    mcpRefreshQueue = run
-    return run
-  }
-
-  function scheduleOnDemandMcpRefresh(): Promise<{ refreshed: string[]; failed: string[] }> {
-    if (mcpRefreshScheduled) return mcpRefreshPromise!
-    mcpRefreshScheduled = true
-    mcpRefreshPromise = queueOnDemandMcpRefresh(false, undefined, 1000)
-    return mcpRefreshPromise
-  }
-
-  function onDemandMcpRuntimeStatus(name: string): "pending" | "ready" | "failed" {
-    const metadata = mcpMetadata[name]
-    if (metadata?.status) return metadata.status
-    return "pending"
-  }
-
-  function displayMcpStatus(status: "pending" | "ready" | "failed"): "pending" | "loaded" | "failed" {
-    return status === "ready" ? "loaded" : status
-  }
-
-  function onDemandMcpStatusBuckets(): { loaded: string[]; failed: string[]; pending: string[] } {
-    const buckets = { loaded: [] as string[], failed: [] as string[], pending: [] as string[] }
-    for (const [name] of activeOnDemandMcpEntries()) {
-      const status = onDemandMcpRuntimeStatus(name)
-      if (status === "ready") buckets.loaded.push(name)
-      else if (status === "failed") buckets.failed.push(name)
-      else buckets.pending.push(name)
-    }
-    return buckets
-  }
-
-  function failedOnDemandMcpNames(names?: string[]): string[] {
-    const configured = activeOnDemandMcpEntries().map(([name]) => name)
-    const wanted = names?.length ? names : configured
-    return wanted.filter((name) => configured.includes(name) && onDemandMcpRuntimeStatus(name) === "failed")
-  }
-
-  function setOnDemandMcpHealth(serverName: string, status: "ready" | "failed", error?: unknown) {
-    const match = getOnDemandMcpServer(serverName)
-    if (!match) return undefined
-    const [name] = match
-    const next: OnDemandMcpMetadata = {
-      ...(mcpMetadata[name] ?? {}),
-      status,
-      lastCheckedAt: new Date().toISOString(),
-    }
-    if (status === "failed") next.lastError = truncateText(error, 500)
-    else delete next.lastError
-    mcpMetadata[name] = next
-    saveMcpMetadata(mcpMetadata)
-    saveDynamicGuidance()
-    return name
-  }
-
-  function onDemandMcpStatus(): string {
-    const entries = activeOnDemandMcpEntries()
-    if (!Object.keys(config.raven_mcp.onDemandMcpServers ?? {}).length) return "Raven on-demand MCPs: none configured."
-    if (!entries.length) return "Raven on-demand MCPs: none enabled."
-    const buckets = onDemandMcpStatusBuckets()
-    const lines = entries.map(([name, server]) => {
-      const metadata = mcpMetadata[name]
-      const source = server.description ? "user description" : "no user description"
-      const generated = metadata?.autoGeneratedDescription ? "generated" : "missing generated description"
-      const tools = metadata?.autoGeneratedTools?.length ? `${metadata.autoGeneratedTools.length} tools` : "tools pending"
-      const status = onDemandMcpRuntimeStatus(name)
-      const avoided = status === "ready" && metadata?.avoidedSchemaBytes ? `, ${formatBytes(metadata.avoidedSchemaBytes)} avoided schema` : ""
-      const error = status === "failed" && metadata?.lastError ? `, error: ${metadata.lastError}` : ""
-      return `- ${name} (${server.type}): ${displayMcpStatus(status)}, ${source}, ${generated}, ${tools}${avoided}${error}`
-    })
-    return `Raven on-demand MCPs (${config.raven_mcp.descriptionDetail ?? "full"} guidance):\n  Loaded: ${buckets.loaded.length ? buckets.loaded.join(", ") : "none"}\n  Failed: ${buckets.failed.length ? buckets.failed.join(", ") : "none"}\n  Pending: ${buckets.pending.length ? buckets.pending.join(", ") : "none"}\n${lines.join("\n")}`
-  }
-
-  function avoidedMcpSchemaBytes(): number {
-    return activeOnDemandMcpEntries().reduce((sum, [name]) => {
-      const metadata = mcpMetadata[name]
-      if (onDemandMcpRuntimeStatus(name) !== "ready") return sum
-      return sum + Math.max(0, metadata?.avoidedSchemaBytes ?? 0)
-    }, 0)
-  }
-
-  function statsText(): string {
-    const avoided = avoidedMcpSchemaBytes()
-    return `Raven context saved:\n  Avoided MCP schema load: ${formatBytes(avoided)} (~${formatTokens(avoided)} context)\n  This session: ${formatBytes(sessionBytes)} (~${formatTokens(sessionBytes)} context)\n  All time: ${formatBytes(totalBytes)} (~${formatTokens(totalBytes)} context)`
-  }
-
-  function helpText(): string {
-    return `Raven commands:\n  /raven help - show this help\n  /raven route - show or edit routed tools/keywords\n  /raven seek model <name> - change the search model (requires restart)\n  /raven seek effort <value> - change search reasoning effort (requires restart)\n  /raven seek timeout <seconds> - change search timeout\n  /raven mcp - show on-demand MCP metadata\n  /raven mcp refresh [server] - refresh MCP metadata\n  /raven mcp detail full|minimized - change MCP guidance detail\n  /raven mcp model <name> - change the MCP model (requires restart)\n  /raven mcp effort <value> - change MCP reasoning effort (requires restart)\n  /raven mcp timeout <seconds> - change MCP delegation timeout\n  /raven update - check for an update\n  /raven stats - show context saved`
-  }
-
-  function formatMcpList(title: string, items: any[], fields: string[] = ["name", "description"]): string {
-    if (!items.length) return `${title}: none found.`
-    const lines = items.map((item) => {
-      const primary = fields.map((field) => item?.[field]).find(Boolean) ?? JSON.stringify(item)
-      const description = item?.description && primary !== item.description ? ` - ${truncateText(item.description, 300)}` : ""
-      return `- ${truncateText(primary, 180)}${description}`
-    })
-    return `${title}:\n${lines.join("\n")}`
-  }
-
-  function formatMcpToolsForRaven(serverName: string, tools: any[]): string {
-    if (!tools.length) return `Tools for ${serverName}: none found.`
-    const lines = tools.map((item) => {
-      const description = item?.description ? `\n  Description: ${truncateText(item.description, 600)}` : ""
-      const schema = item?.inputSchema ? `\n  Input schema: ${truncateText(JSON.stringify(item.inputSchema), 3000)}` : ""
-      return `- ${item?.name ?? "(unnamed)"}${description}${schema}`
-    })
-    return `Tools for ${serverName}:\n${lines.join("\n")}`
-  }
-
-  function formatMcpResult(result: any): string {
-    if (!result) return "No result."
-    if (Array.isArray(result.content)) {
-      const parts = result.content.map((part: any) => {
-        if (part?.type === "text") return part.text
-        return JSON.stringify(part)
-      })
-      return parts.join("\n") || JSON.stringify(result)
-    }
-    return typeof result === "string" ? result : JSON.stringify(result, null, 2)
-  }
-
-  function parseMcpArguments(raw: string | undefined): Record<string, any> {
-    if (!raw?.trim()) return {}
-    const parsed = JSON.parse(raw)
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      throw new Error("argumentsJson must be a JSON object")
-    }
-    return parsed
-  }
-
-  // ── Context saved by Raven delegation ──
-  let sessionBytes = 0
-  let totalBytes = config.stats?.bytes ?? 0
-
-  function addBytes(bytes: number) {
-    sessionBytes += bytes
-    const updated = updateConfig((latest) => ({
-      stats: { bytes: Math.max(totalBytes, latest.stats?.bytes ?? 0) + bytes },
-    }))
-    totalBytes = updated.stats?.bytes ?? totalBytes + bytes
-  }
-
-  function formatBytes(bytes: number): string {
-    return bytes >= 1_000_000 ? `${(bytes / 1_000_000).toFixed(1)}MB`
-      : bytes >= 1000 ? `${(bytes / 1000).toFixed(1)}KB`
-      : `${bytes}B`
-  }
-
-  function formatTokens(bytes: number): string {
-    const tokens = Math.round(bytes / 4)
-    return tokens >= 1_000_000 ? `${(tokens / 1_000_000).toFixed(1)}M`
-      : tokens >= 1000 ? `${(tokens / 1000).toFixed(1)}K`
-      : `${tokens}`
-  }
-
-  function compareVersions(a: string, b: string): number {
-    const parse = (v: string) => v.replace(/^v/, "").split(/[.-]/).map((part) => Number.parseInt(part, 10) || 0)
-    const left = parse(a)
-    const right = parse(b)
-    const len = Math.max(left.length, right.length)
-    for (let i = 0; i < len; i++) {
-      const diff = (left[i] ?? 0) - (right[i] ?? 0)
-      if (diff !== 0) return diff
-    }
-    return 0
-  }
-
-  async function fetchLatestVersion(): Promise<string | undefined> {
-    const controller = new AbortController()
-    const timeout = setTimeout(() => controller.abort(), 5000)
-    try {
-      const res = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, {
-        headers: { accept: "application/json" },
-        signal: controller.signal,
-      })
-      if (!res.ok) return undefined
-      const data = await res.json() as { version?: string }
-      return data.version
-    } finally {
-      clearTimeout(timeout)
-    }
-  }
-
-  async function checkForUpdate(): Promise<{ current: string; latest?: string; available: boolean }> {
-    const latest = await fetchLatestVersion()
-    return { current: PACKAGE_VERSION, latest, available: !!latest && compareVersions(latest, PACKAGE_VERSION) > 0 }
-  }
-
-  function estimateRavenSavedCandidateBytes(messages: any[]): number {
-    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)
-    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 countRavenSavedCandidateBytes(sessionId: string, signal?: AbortSignal): Promise<number> {
-    const messagesResp = await client.session.messages({ path: { id: sessionId }, signal })
-    const messages = (messagesResp as any)?.data ?? []
-    return estimateRavenSavedCandidateBytes(messages)
-  }
-
-  async function getUpdateInfo(): Promise<{ current: string; latest?: string; available: boolean }> {
-    if (updateInfo) return updateInfo
-    if (!updateCheckPromise) {
-      updateCheckPromise = checkForUpdate()
-        .then((info) => {
-          updateInfo = info
-          return info
-        })
-        .catch((err) => {
-          updateCheckPromise = undefined
-          throw err
-        })
-    }
-    return updateCheckPromise
-  }
-
-  async function refreshUpdateInfo(): Promise<{ current: string; latest?: string; available: boolean }> {
-    updateInfo = undefined
-    updateCheckPromise = checkForUpdate()
-      .then((info) => {
-        updateInfo = info
-        return info
-      })
-      .catch((err) => {
-        updateCheckPromise = undefined
-        throw err
-      })
-    return updateCheckPromise
-  }
-
-  function clearPluginCache(): string[] {
-    const packagesDir = join(homedir(), ".cache", "opencode", "packages")
-    if (!existsSync(packagesDir)) return []
-
-    const removed: string[] = []
-    for (const entry of readdirSync(packagesDir)) {
-      if (entry !== PACKAGE_NAME && !entry.startsWith(`${PACKAGE_NAME}@`)) continue
-      const target = join(packagesDir, entry)
-      rmSync(target, { recursive: true, force: true })
-      removed.push(target)
-    }
-    return removed
-  }
-
-  function manualUpdateText(latest = "latest"): string {
-    return `Restart opencode to load the update.\n\nManual alternatives:\n  bun update --latest ${PACKAGE_NAME}\n  npm install ${PACKAGE_NAME}@${latest}\n\nIf opencode still loads the old version, clear its plugin cache and restart:\n  PowerShell: Remove-Item -Recurse -Force "$HOME\\.cache\\opencode\\packages\\${PACKAGE_NAME}*"\n  macOS/Linux: rm -rf ~/.cache/opencode/packages/${PACKAGE_NAME}*`
-  }
-
-  async function notifyIfUpdateAvailable() {
-    try {
-      const info = await getUpdateInfo()
-      if (!info.available || !info.latest) return
-      await (client as any).tui?.showToast?.({
-        body: {
-          title: "Raven update available",
-          message: `${PACKAGE_NAME} ${info.current} → ${info.latest}. Run /raven update, then restart opencode.`,
-          variant: "info",
-          duration: 10000,
-        },
-      })
-    } catch { /* update checks are best-effort */ }
-  }
-
-  async function notifyIfMcpFailures(names?: string[]) {
-    try {
-      const failed = failedOnDemandMcpNames(names)
-      if (!failed.length) {
-        lastNotifiedMcpFailureKey = ""
-        return
-      }
-      const key = failed.sort().join("|")
-      if (key === lastNotifiedMcpFailureKey) return
-      lastNotifiedMcpFailureKey = key
-      const label = failed.length === 1 ? failed[0] : `${failed.length} on-demand MCPs`
-      await (client as any).tui?.showToast?.({
-        body: {
-          title: "Raven MCP warning",
-          message: `${label} failed to load. Run /raven mcp for details.`,
-          variant: "warning",
-          duration: 12000,
-        },
-      })
-    } catch { /* MCP failure notifications are best-effort */ }
-  }
-
-  async function notifyIfDuplicateMcps() {
-    try {
-      if (!duplicateMcpServers.length) return
-      const label = duplicateMcpServers.length === 1 ? duplicateMcpServers[0] : `${duplicateMcpServers.length} MCPs`
-      await (client as any).tui?.showToast?.({
-        body: {
-          title: "Raven MCP duplicate config",
-          message: `${label} configured both globally and on-demand. Prefer one location to avoid duplicate schema/connection behavior.`,
-          variant: "warning",
-          duration: 12000,
-        },
-      })
-    } catch { /* duplicate MCP notifications are best-effort */ }
-  }
-
-  function delegationAgent(kind: DelegationKind): "raven" | "raven-mcp" {
-    return kind === "mcp" ? "raven-mcp" : "raven"
-  }
-
-  function delegationToolName(kind: DelegationKind): "raven_seek" | "raven_mcp" {
-    return kind === "mcp" ? "raven_mcp" : "raven_seek"
-  }
-
-  function delegationTitle(kind: DelegationKind): string {
-    return kind === "mcp" ? "Raven MCP" : "Raven Seek"
-  }
-
-  async function rootSessionId(sessionId: string, signal?: AbortSignal): Promise<string> {
-    let current = sessionId
-    const seen = new Set<string>()
-    while (!seen.has(current)) {
-      seen.add(current)
-      const response = await client.session.get({ path: { id: current }, signal })
-      const session = (response as any)?.data ?? response
-      if (!session?.parentID) return current
-      current = session.parentID
-    }
-    return sessionId
-  }
-
-  async function syncCreatedSession(sessionId: string, title: string, signal?: AbortSignal) {
-    try {
-      await client.session.update({
-        path: { id: sessionId },
-        body: { title },
-        signal,
-      })
-    } catch (error) {
-      if (signal?.aborted) throw error
-      // Delegation still works if an older or disconnected TUI misses the sync event.
-    }
-  }
-
-  async function executeRavenDelegation(kind: DelegationKind, args: { query: string; sessionId?: string }, context: any) {
-    const started = Date.now()
-    const agent = delegationAgent(kind)
-    const toolName = delegationToolName(kind)
-    const title = delegationTitle(kind)
-    const timeout = (kind === "mcp" ? config.raven_mcp.timeout : config.raven_seek.timeout) ?? 600
-    const timeoutMs = timeout * 1000
-    let sessionId: string | undefined
-    let resumed = false
-    let previousSavedCandidate = 0
-
-    try {
-      const requestedSessionId = args.sessionId?.trim()
-      if (args.sessionId !== undefined && !requestedSessionId) {
-        return { title, output: "Cannot resume Raven: sessionId must not be empty." }
-      }
-
-      let rootId = context.sessionID
-      try {
-        rootId = await rootSessionId(context.sessionID, context.abort)
-      } catch (error) {
-        if (context.abort.aborted) throw error
-        // Falling back preserves delegation if an older OpenCode build cannot read the caller session.
-      }
-
-      if (requestedSessionId) {
-        const knownKind = ravenSessionKinds.get(requestedSessionId)
-        const knownRavenSession = knownKind === kind || sessionAgents.get(requestedSessionId) === agent
-        let existingSession: any
-        try {
-          const sessionResp = await client.session.get({ path: { id: requestedSessionId }, signal: context.abort })
-          existingSession = (sessionResp as any)?.data ?? sessionResp
-        } catch (error) {
-          if (context.abort.aborted) throw error
-          return { title, output: `Cannot resume Raven session ${requestedSessionId}: the session was not found or could not be read.` }
-        }
-
-        if (!existingSession?.id || existingSession.id !== requestedSessionId) {
-          return { title, output: `Cannot resume Raven session ${requestedSessionId}: the session was not found or could not be read.` }
-        }
-        const validParent = existingSession.parentID === rootId || existingSession.parentID === context.sessionID
-        if (!validParent || existingSession.projectID !== input.project.id) {
-          return { title, output: "Cannot resume Raven: sessionId is not part of this main session's Raven tree." }
-        }
-
-        let messages: any[]
-        try {
-          const messagesResp = await client.session.messages({ path: { id: requestedSessionId }, signal: context.abort })
-          const messageData = (messagesResp as any)?.data
-          if (!Array.isArray(messageData)) {
-            return { title, output: `Cannot resume Raven session ${requestedSessionId}: its message history could not be read.` }
-          }
-          messages = messageData
-        } catch (error) {
-          if (context.abort.aborted) throw error
-          return { title, output: `Cannot resume Raven session ${requestedSessionId}: its message history could not be read.` }
-        }
-
-        const userMessages = messages.filter((message: any) => message?.info?.role === "user")
-        const persistedRavenSession = userMessages.length > 0
-          && userMessages.every((message: any) => message.info.agent === agent)
-        if (!persistedRavenSession && !(knownRavenSession && userMessages.length === 0)) {
-          return { title, output: `Cannot resume Raven: sessionId does not belong to the ${agent} agent.` }
-        }
-
-        sessionId = requestedSessionId
-        resumed = true
-        previousSavedCandidate = estimateRavenSavedCandidateBytes(messages)
-      } else {
-        const sessionTitle = `${toolName}: ${args.query.slice(0, 80)}`
-        const session = await client.session.create({
-          body: {
-            parentID: rootId,
-            title: sessionTitle,
-          },
-          signal: context.abort,
-        })
-        sessionId = (session as any)?.data?.id ?? (session as any)?.id
-        if (!sessionId) return { title, output: "Failed to create Raven session." }
-        await syncCreatedSession(sessionId, sessionTitle, context.abort)
-      }
-
-      ravenSessions.add(sessionId)
-      ravenSessionKinds.set(sessionId, kind)
-      const activeSessionId = sessionId
-      context.metadata({ metadata: { sessionId } })
-
-      try {
-        writeFileSync(join(tmpdir(), "raven-sessions.log"), `${new Date().toISOString()} ${sessionId}\n`)
-      } catch { /* non-fatal */ }
-
-      if (activeRavenPrompts.has(activeSessionId)) {
-        return {
-          title,
-          metadata: { sessionId: activeSessionId },
-          output: `Raven session \`${activeSessionId}\` is already handling a request. Wait for it to finish before sending another follow-up.`,
-        }
-      }
-      activeRavenPrompts.add(activeSessionId)
-
-      let timer: ReturnType<typeof setTimeout> | undefined
-      let promptCompleted = false
-      let sessionAbort: Promise<unknown> | undefined
-      const promptController = new AbortController()
-      const abortPrompt = () => {
-        if (promptController.signal.aborted) return
-        promptController.abort(context.abort.reason)
-        const abortController = new AbortController()
-        const abortTimer = setTimeout(() => abortController.abort(), Math.min(timeoutMs, 5_000))
-        sessionAbort = client.session.abort({
-          path: { id: activeSessionId },
-          signal: abortController.signal,
-          throwOnError: true,
-        }).catch(() => undefined).finally(() => clearTimeout(abortTimer))
-      }
-      if (context.abort.aborted) abortPrompt()
-      else context.abort.addEventListener("abort", abortPrompt, { once: true })
-      const providerError = waitForRavenProviderError(sessionId)
-      const firstProgress = waitForRavenFirstProgress(sessionId, Math.min(timeoutMs, 30_000))
-
-      try {
-        const result = await Promise.race([
-          client.session.prompt({
-            path: { id: sessionId },
-            body: { agent, parts: [{ type: "text", text: args.query }] },
-            signal: promptController.signal,
-            throwOnError: true,
-          }),
-          providerError,
-          firstProgress,
-          new Promise<never>((_, reject) => {
-            timer = setTimeout(() => {
-              abortPrompt()
-              reject(new Error(`Raven timed out after ${timeout}s - child session retained: ${sessionId}`))
-            }, timeoutMs)
-          }),
-        ])
-        promptCompleted = true
-        if (timer) clearTimeout(timer)
-        clearRavenWaiters(sessionId)
-        if ((result as any)?.error) throw new Error(providerErrorMessage((result as any).error))
-
-        const elapsed = ((Date.now() - started) / 1000).toFixed(1)
-        const parts = (result as any)?.data?.parts ?? []
-        const output = parts
-          .filter((part: any) => part.type === "text" && part.text)
-          .map((part: any) => part.text)
-          .join("\n") || "Raven returned no results."
-
-        let savedCandidate = 0
-        const statsController = new AbortController()
-        const abortStats = () => statsController.abort(context.abort.reason)
-        const statsTimer = setTimeout(() => statsController.abort(), Math.min(timeoutMs, 5_000))
-        if (context.abort.aborted) abortStats()
-        else context.abort.addEventListener("abort", abortStats, { once: true })
-        try {
-          const totalSavedCandidate = await countRavenSavedCandidateBytes(sessionId, statsController.signal)
-          savedCandidate = Math.max(0, totalSavedCandidate - previousSavedCandidate)
-        } catch { /* best-effort */ }
-        finally {
-          clearTimeout(statsTimer)
-          context.abort.removeEventListener("abort", abortStats)
-        }
-        if (savedCandidate <= 0) {
-          for (const part of parts) {
-            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
-          }
-        }
-
-        const continuation = `Raven session: \`${sessionId}\`${resumed ? " (continued)" : ""}. Pass this as \`sessionId\` in a later \`${toolName}\` call to continue the same retrieval.`
-        const activity = kind === "mcp" ? "used MCPs" : "searched"
-        const resultOutput = `${output}\n\n*Raven ${activity} for ${elapsed}s - ${formatBytes(savedCandidate)} handled, ${formatTokens(savedCandidate)} tokens*\n\n${continuation}`
-        addBytes(Math.max(0, savedCandidate - resultOutput.length))
-        delete ravenProviderIssues[kind]
-        return { title, metadata: { sessionId }, output: resultOutput }
-      } finally {
-        context.abort.removeEventListener("abort", abortPrompt)
-        if (!promptCompleted) abortPrompt()
-        if (sessionAbort) await sessionAbort
-        if (timer) clearTimeout(timer)
-        clearRavenWaiters(sessionId)
-        activeRavenPrompts.delete(activeSessionId)
-      }
-    } catch (error: any) {
-      const elapsed = ((Date.now() - started) / 1000).toFixed(1)
-      const message = String(error?.message ?? error ?? "").toLowerCase()
-      const missingSession = /session.*not found|not found.*session/i.test(message)
-      const activity = kind === "mcp" ? "MCP retrieval" : "search"
-      const hint =
-        context.abort.aborted ? `Raven ${activity} cancelled.`
-        : /rate.?limit|too many requests|429/i.test(message) ? "Raven rate limited - wait 30s, then retry with a narrower query."
-        : /quota|usage.?limit|usage exceeded|free usage|subscribe to go|subscription|billing|insufficient.*(?:credit|balance|quota)/i.test(message) ? "Raven API quota/subscription exhausted - proceed without Raven and mention what information may be missing."
-        : /auth|unauthorized|forbidden|401|403|api key|login/i.test(message) ? "Raven provider authentication failed - proceed without Raven and check the configured provider login or API key."
-        : /token|context.?length|too large|too long/i.test(message) ? "Raven query too large - shorten your query and retry."
-        : missingSession ? `The Raven session is no longer available - retry without sessionId to start a new ${activity}.`
-        : /model|unavailable|down|not found/i.test(message) ? "Raven model unavailable - retry later, or proceed without the missing information."
-        : /did not produce an initial response|retry dialog|timeout|timed.?out|session retained/i.test(message) ? error.message
-        : `Raven ${activity} failed. Note the resulting information gap. [${error.message || error}]`
-      if (!missingSession && /quota|usage.?limit|usage exceeded|free usage|subscribe to go|subscription|billing|auth|unauthorized|forbidden|401|403|api key|login|model|unavailable|down|not found|did not produce an initial response|retry dialog/i.test(message)) {
-        ravenProviderIssues[kind] = hint
-      }
-      const recovery = ravenProviderIssues[kind] ? `\n\n${ravenRecoveryInstructions(kind)}` : ""
-      const continuation = sessionId && !missingSession
-        ? `\n\nRaven session: \`${sessionId}\`. Pass this as \`sessionId\` in a later \`${toolName}\` call to retry or continue.`
-        : ""
-      return { title, metadata: sessionId ? { sessionId } : undefined, output: `${hint}${recovery}\n\n*Attempt took ${elapsed}s*${continuation}` }
-    }
-  }
-
-  return {
-    async dispose() {
-      for (const controller of mcpRefreshControllers) controller.abort()
-      for (const attempt of mcpConnectionAttempts.values()) attempt.controller.abort()
-      await Promise.allSettled([
-        ...[...mcpConnectionAttempts.values()].map((attempt) => attempt.promise),
-        mcpRefreshQueue,
-      ])
-      await Promise.all([...mcpConnections.keys()].map((key) => closeMcpConnectionKey(key)))
-      if (mcpIdleTimer) clearInterval(mcpIdleTimer)
-      mcpIdleTimer = undefined
-      for (const sessionId of ravenProgressWaiters.keys()) clearRavenWaiters(sessionId)
-      ravenErrorWaiters.clear()
-    },
-
-    async config(configInput: any) {
-      globalMcpServers = uniqueStrings(Object.entries(configInput.mcp ?? {})
-        .filter(([, value]) => !value || typeof value !== "object" || (value as any).enabled !== false)
-        .map(([name]) => name))
-      const onDemandNames = new Set(activeOnDemandMcpEntries().map(([name]) => name.toLowerCase()))
-      duplicateMcpServers = globalMcpServers.filter((name) => onDemandNames.has(name.toLowerCase()))
-
-      // Inject MCP guidance as a startup instruction file (absolute path for npm compat).
-      // The file is regenerated after MCP health checks, not during the startup pending reset.
-      configInput.instructions = configInput.instructions || []
-      if (!configInput.instructions.includes(MCP_GUIDANCE_MD)) {
-        configInput.instructions.push(MCP_GUIDANCE_MD)
-      }
-      if (!configInput.instructions.includes(dynamicGuidanceFile)) {
-        configInput.instructions.push(dynamicGuidanceFile)
-      }
-
-      // Register Raven from Raven.md, with config file overrides
-      configInput.agent = configInput.agent || {}
-      configInput.agent.raven = {
-        description: fm.description || "",
-        mode: fm.mode || "subagent",
-        hidden: fm.hidden !== undefined ? fm.hidden : false,
-        model: config.raven_seek.model || fm.model,
-        options: {
-          ...extractOptions(fm),
-          ...(config.raven_seek.reasoning_effort ? { reasoning_effort: config.raven_seek.reasoning_effort } : {}),
-        },
-        permission: fm.permission || {},
-        prompt: ravenAgentPrompt(),
-      }
-      configInput.agent["raven-mcp"] = {
-        description: mcpFm.description || "",
-        mode: mcpFm.mode || "subagent",
-        hidden: mcpFm.hidden !== undefined ? mcpFm.hidden : true,
-        model: config.raven_mcp.model || mcpFm.model,
-        options: {
-          ...extractOptions(mcpFm),
-          ...(config.raven_mcp.reasoning_effort ? { reasoning_effort: config.raven_mcp.reasoning_effort } : {}),
-        },
-        permission: mcpFm.permission || {},
-        prompt: ravenMcpAgentPrompt(),
-      }
-
-      // Register /raven command
-      configInput.command = configInput.command || {}
-      if (!configInput.command.raven) {
-        configInput.command.raven = {
-          template: "Manage Raven search routing, on-demand MCPs, models, timeouts, updates, and status",
-          description: "Manage Raven search routing, on-demand MCPs, and per-agent models",
-        }
-      }
-
-      scheduleOnDemandMcpRefresh()
-      updateToastPending = true
-      mcpFailureToastPending = true
-      duplicateMcpToastPending = duplicateMcpServers.length > 0
-    },
-
-    // Register raven_seek tool — lets agents with task:false still delegate through Raven
-    tool: {
-      "raven_seek": tool({
-        description: "Search and evidence retrieval only. Creates or resumes a Raven Search session for routed local search, filesystem discovery, URL fetching, web/docs/GitHub search, globally configured MCP searches, or command-output inspection. Do not delegate code review, auditing, correctness judgments, implementation, debugging decisions, planning, or general task execution; the calling agent must perform that work.",
-        args: {
-          query: tool.schema.string().describe("A narrowly scoped search or evidence-retrieval request. Include original blocked tool args, exact URLs, paths, patterns, or bounded command-output checks. Do not ask Raven to review or audit code."),
-          sessionId: tool.schema.string().optional().describe("Raven session ID returned by an earlier raven_seek call. Provide it only when this request should continue that session's research context."),
-        },
-        async execute(args, context) {
-          const started = Date.now()
-          const timeout = (config.raven_seek.timeout ?? 600) * 1000
-          let sessionId: string | undefined
-          let resumed = false
-          let previousSavedCandidate = 0
-          try {
-            const requestedSessionId = args.sessionId?.trim()
-            if (args.sessionId !== undefined && !requestedSessionId) {
-              return { title: "Raven Seek", output: "Cannot resume Raven: sessionId must not be empty." }
-            }
-
-            let rootId = context.sessionID
-            try {
-              rootId = await rootSessionId(context.sessionID, context.abort)
-            } catch (error) {
-              if (context.abort.aborted) throw error
-            }
-
-            if (requestedSessionId) {
-              const knownRavenSession = ravenSessionKinds.get(requestedSessionId) === "seek" || sessionAgents.get(requestedSessionId) === "raven"
-              let existingSession: any
-              try {
-                const sessionResp = await client.session.get({ path: { id: requestedSessionId }, signal: context.abort })
-                existingSession = (sessionResp as any)?.data ?? sessionResp
-              } catch (err) {
-                if (context.abort.aborted) throw err
-                return { title: "Raven Seek", output: `Cannot resume Raven session ${requestedSessionId}: the session was not found or could not be read.` }
-              }
-
-              if (!existingSession?.id || existingSession.id !== requestedSessionId) {
-                return { title: "Raven Seek", output: `Cannot resume Raven session ${requestedSessionId}: the session was not found or could not be read.` }
-              }
-              if ((existingSession.parentID !== rootId && existingSession.parentID !== context.sessionID) || existingSession.projectID !== input.project.id) {
-                return { title: "Raven Seek", output: "Cannot resume Raven: sessionId is not a Raven child of this main session." }
-              }
-
-              let messages: any[]
-              try {
-                const messagesResp = await client.session.messages({ path: { id: requestedSessionId }, signal: context.abort })
-                const messageData = (messagesResp as any)?.data
-                if (!Array.isArray(messageData)) {
-                  return { title: "Raven Seek", output: `Cannot resume Raven session ${requestedSessionId}: its message history could not be read.` }
-                }
-                messages = messageData
-              } catch (err) {
-                if (context.abort.aborted) throw err
-                return { title: "Raven Seek", output: `Cannot resume Raven session ${requestedSessionId}: its message history could not be read.` }
-              }
-
-              const userMessages = messages.filter((message: any) => message?.info?.role === "user")
-              const persistedRavenSession = userMessages.length > 0
-                && userMessages.every((message: any) => message.info.agent === "raven")
-              if (!persistedRavenSession && !(knownRavenSession && userMessages.length === 0)) {
-                return { title: "Raven Seek", output: "Cannot resume Raven: sessionId is not a Raven child of this main session." }
-              }
-
-              sessionId = requestedSessionId
-              resumed = true
-              previousSavedCandidate = estimateRavenSavedCandidateBytes(messages)
-            } else {
-              const sessionTitle = `raven_seek: ${args.query.slice(0, 80)}`
-              const session = await client.session.create({
-                body: {
-                  parentID: rootId,
-                  title: sessionTitle,
-                },
-                signal: context.abort,
-              })
-
-              sessionId = (session as any)?.data?.id ?? (session as any)?.id
-              if (!sessionId) {
-                return { title: "Raven Seek", output: "Failed to create Raven session." }
-              }
-              await syncCreatedSession(sessionId, sessionTitle, context.abort)
-            }
-
-            ravenSessions.add(sessionId)
-            ravenSessionKinds.set(sessionId, "seek")
-            const activeSessionId = sessionId
-
-            // Preserve the child session link for TUI clients that render it.
-            context.metadata({ metadata: { sessionId } })
-
-            // Log session for debugging
-            try {
-              const logFile = join(tmpdir(), "raven-sessions.log")
-              const ts = new Date().toISOString()
-              writeFileSync(logFile, `${ts} ${sessionId}\n`)
-            } catch { /* non-fatal */ }
-
-            if (activeRavenPrompts.has(activeSessionId)) {
-              return {
-                title: "Raven Seek",
-                metadata: { sessionId: activeSessionId },
-                output: `Raven session \`${activeSessionId}\` is already handling a request. Wait for it to finish before sending another follow-up.`,
-              }
-            }
-            activeRavenPrompts.add(activeSessionId)
-
-            // Send the query to Raven with timeout. Provider/API errors are also
-            // surfaced through message.updated events; fail as soon as one lands
-            // so the caller does not wait for the full timeout on quota/auth issues.
-            let timer: ReturnType<typeof setTimeout> | undefined
-            let promptCompleted = false
-            let sessionAbort: Promise<unknown> | undefined
-            const promptController = new AbortController()
-            const abortPrompt = () => {
-              if (promptController.signal.aborted) return
-              promptController.abort(context.abort.reason)
-              const abortController = new AbortController()
-              const abortTimer = setTimeout(() => abortController.abort(), Math.min(timeout, 5_000))
-              sessionAbort = client.session.abort({
-                path: { id: activeSessionId },
-                signal: abortController.signal,
-                throwOnError: true,
-              }).catch(() => undefined).finally(() => clearTimeout(abortTimer))
-            }
-            if (context.abort.aborted) abortPrompt()
-            else context.abort.addEventListener("abort", abortPrompt, { once: true })
-            const providerError = waitForRavenProviderError(sessionId)
-            const firstProgress = waitForRavenFirstProgress(sessionId, Math.min(timeout, 30_000))
-            try {
-              const result = await Promise.race([
-                client.session.prompt({
-                  path: { id: sessionId },
-                  body: {
-                    agent: "raven",
-                    parts: [{ type: "text", text: args.query }],
-                  },
-                  signal: promptController.signal,
-                  throwOnError: true,
-                }),
-                providerError,
-                firstProgress,
-                new Promise<never>((_, reject) => {
-                  timer = setTimeout(() => {
-                    abortPrompt()
-                    reject(new Error(`Raven timed out after ${timeout / 1000}s — child session retained: ${sessionId}`))
-                  }, timeout)
-                }),
-              ])
-              promptCompleted = true
-              if (timer) clearTimeout(timer)
-              clearRavenWaiters(sessionId)
-              if ((result as any)?.error) throw new Error(providerErrorMessage((result as any).error))
-
-              const elapsed = ((Date.now() - started) / 1000).toFixed(1)
-
-              // Extract text from the response
-              const parts = (result as any)?.data?.parts ?? []
-              const textParts = parts
-                .filter((p: any) => p.type === "text" && p.text)
-                .map((p: any) => p.text)
-              const output = textParts.join("\n") || "Raven returned no results."
-
-              // Context saved = Raven output/reasoning/cache context - compact answer returned to main session.
-              let savedCandidate = 0
-              const statsController = new AbortController()
-              const abortStats = () => statsController.abort(context.abort.reason)
-              const statsTimer = setTimeout(() => statsController.abort(), Math.min(timeout, 5_000))
-              if (context.abort.aborted) abortStats()
-              else context.abort.addEventListener("abort", abortStats, { once: true })
-              try {
-                const totalSavedCandidate = await countRavenSavedCandidateBytes(sessionId, statsController.signal)
-                savedCandidate = Math.max(0, totalSavedCandidate - previousSavedCandidate)
-              } catch { /* best-effort */ }
-              finally {
-                clearTimeout(statsTimer)
-                context.abort.removeEventListener("abort", abortStats)
-              }
-              if (savedCandidate <= 0) {
-                for (const part of parts) {
-                  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
-                }
-              }
-              const continuation = `Raven session: \`${sessionId}\`${resumed ? " (continued)" : ""}. Pass this as \`sessionId\` in a later \`raven_seek\` call to continue the same research.`
-              const resultOutput = `${output}\n\n*Raven searched for ${elapsed}s — ${formatBytes(savedCandidate)} handled, ${formatTokens(savedCandidate)} tokens*\n\n${continuation}`
-              addBytes(Math.max(0, savedCandidate - resultOutput.length))
-              delete ravenProviderIssues.seek
-
-              return { title: "Raven Seek", metadata: { sessionId }, output: resultOutput }
-            } finally {
-              context.abort.removeEventListener("abort", abortPrompt)
-              if (!promptCompleted) abortPrompt()
-              if (sessionAbort) await sessionAbort
-              if (timer) clearTimeout(timer)
-              clearRavenWaiters(sessionId)
-              activeRavenPrompts.delete(activeSessionId)
-            }
-          } catch (err: any) {
-            const elapsed = ((Date.now() - started) / 1000).toFixed(1)
-            const msg = String(err?.message ?? err ?? "").toLowerCase()
-            const missingSession = /session.*not found|not found.*session/i.test(msg)
-            const hint =
-              context.abort.aborted ? "Raven search cancelled."
-              : /rate.?limit|too many requests|429/i.test(msg) ? "Raven rate limited — wait 30s then retry with a narrower query."
-              : /quota|usage.?limit|usage exceeded|free usage|subscribe to go|subscription|billing|insufficient.*(?:credit|balance|quota)/i.test(msg) ? "Raven API quota/subscription exhausted — proceed without Raven, tell the user Raven could not run, and mention what information may be missing."
-              : /auth|unauthorized|forbidden|401|403|api key|login/i.test(msg) ? "Raven provider authentication failed — proceed without Raven and tell the user to check the Raven model/provider login or API key."
-              : /token|context.?length|too large|too long/i.test(msg) ? "Raven query too large — shorten your query and retry."
-              : missingSession ? "The Raven session is no longer available — retry without sessionId to start a new Raven search."
-              : /model|unavailable|down|not found/i.test(msg) ? "Raven model unavailable — retry later, or proceed without search."
-              : /did not produce an initial response|retry dialog/i.test(msg) ? err.message
-              : /timeout|timed.?out|session kept/i.test(msg) ? err.message
-              : `Raven search failed. Proceed without search — note gaps for the user. [${err.message || err}]`
-            if (!missingSession && /quota|usage.?limit|usage exceeded|free usage|subscribe to go|subscription|billing|auth|unauthorized|forbidden|401|403|api key|login|model|unavailable|down|not found|did not produce an initial response|retry dialog/i.test(msg)) {
-              ravenProviderIssues.seek = hint
-            }
-            const recovery = ravenProviderIssues.seek ? `\n\n${ravenRecoveryInstructions("seek")}` : ""
-            const continuation = sessionId && !missingSession
-              ? `\n\nRaven session: \`${sessionId}\`. Pass this as \`sessionId\` in a later \`raven_seek\` call to retry or continue.`
-              : ""
-            return { title: "Raven Seek", metadata: sessionId ? { sessionId } : undefined, output: `${hint}${recovery}\n\n*Attempt took ${elapsed}s*${continuation}` }
-          }
-        },
-      }),
-      "raven_mcp": tool({
-        description: "On-demand MCP information retrieval only. Creates or resumes a dedicated Raven MCP session that selects and calls MCPs configured under raven_mcp.onDemandMcpServers. Use for matching MCP capabilities, not local search, code review, auditing, implementation, planning, or general task delegation.",
-        args: {
-          query: tool.schema.string().describe("The information to retrieve and, when known, the target MCP server or capability. The calling agent retains analysis and judgment."),
-          sessionId: tool.schema.string().optional().describe("Raven MCP session ID returned by an earlier raven_mcp call. Provide it only to continue that MCP retrieval context."),
-        },
-        async execute(args, context) {
-          return executeRavenDelegation("mcp", args, context)
-        },
-      }),
-      "raven_mcp_bridge": tool({
-        description: "Internal bridge for the Raven MCP agent. Other agents must not call this tool. Lists and calls tools, resources, and prompts from configured on-demand MCP servers without globally exposing their schemas.",
-        args: {
-          server: tool.schema.string().describe("On-demand MCP server name from Raven config, e.g. context7, exa, grep_app, unityMCP."),
-          operation: tool.schema.enum(["list_tools", "call_tool", "list_resources", "read_resource", "list_prompts", "get_prompt"]).describe("MCP operation to perform."),
-          name: tool.schema.string().optional().describe("Tool name for call_tool, resource URI for read_resource, or prompt name for get_prompt."),
-          argumentsJson: tool.schema.string().optional().describe("JSON object string with arguments for call_tool or get_prompt, e.g. {\"query\":\"latest AI news\"}. Omit for no arguments."),
-        },
-        async execute(args, context) {
-          if (ravenSessionKinds.get(context.sessionID) !== "mcp" && sessionAgents.get(context.sessionID) !== "raven-mcp") {
-            return { title: "Raven MCP Bridge", output: "raven_mcp_bridge is only available inside the Raven MCP agent. Use raven_mcp for on-demand MCP requests." }
-          }
-
-          const operation = args.operation as RavenMcpOperation
-          const server = getOnDemandMcpServer(args.server)?.[1]
-          const timeout = server ? mcpTimeoutMs(server) : (config.raven_mcp.timeout ?? 600) * 1000
-          const requestOptions = { signal: context.abort, timeout }
-          let connected = false
-          let connection: McpConnection | undefined
-          try {
-            connection = await getMcpConnection(context.sessionID, args.server, context.abort)
-            connected = true
-            connection.active++
-            connection.lastUsed = Date.now()
-            const client = connection.client
-
-            if (operation === "list_tools") {
-              const tools = await listAllMcpTools(client, requestOptions)
-              const match = getOnDemandMcpServer(args.server)
-              if (match) {
-                const [name] = match
-                const generatedTools = generatedToolsFromMcpTools(tools)
-                mcpMetadata[name] = {
-                  autoGeneratedTools: generatedTools,
-                  autoGeneratedDescription: mcpMetadata[name]?.autoGeneratedDescription || synthesizeMcpDescription(name, generatedTools),
-                  avoidedSchemaBytes: estimateAvoidedMcpSchemaBytes(tools),
-                  status: "ready",
-                  lastCheckedAt: new Date().toISOString(),
-                }
-                saveMcpMetadata(mcpMetadata)
-                saveDynamicGuidance()
-              }
-              return { title: `Raven MCP: ${args.server}`, output: formatMcpToolsForRaven(args.server, tools) }
-            }
-
-            if (operation === "call_tool") {
-              if (!args.name) return { title: `Raven MCP: ${args.server}`, output: "call_tool requires name." }
-              const result = await client.callTool({ name: args.name, arguments: parseMcpArguments(args.argumentsJson) }, undefined, requestOptions)
-              setOnDemandMcpHealth(args.server, "ready")
-              return { title: `Raven MCP: ${args.server}.${args.name}`, output: formatMcpResult(result) }
-            }
-
-            if (operation === "list_resources") {
-              const resources = await listAllMcpResources(client, requestOptions)
-              setOnDemandMcpHealth(args.server, "ready")
-              return { title: `Raven MCP: ${args.server}`, output: formatMcpList(`Resources for ${args.server}`, resources, ["uri", "name", "description"]) }
-            }
-
-            if (operation === "read_resource") {
-              if (!args.name) return { title: `Raven MCP: ${args.server}`, output: "read_resource requires name as the resource URI." }
-              const result = await client.readResource({ uri: args.name }, requestOptions)
-              setOnDemandMcpHealth(args.server, "ready")
-              return { title: `Raven MCP: ${args.server}`, output: formatMcpResult(result) }
-            }
-
-            if (operation === "list_prompts") {
-              const prompts = await listAllMcpPrompts(client, requestOptions)
-              setOnDemandMcpHealth(args.server, "ready")
-              return { title: `Raven MCP: ${args.server}`, output: formatMcpList(`Prompts for ${args.server}`, prompts) }
-            }
-
-            if (operation === "get_prompt") {
-              if (!args.name) return { title: `Raven MCP: ${args.server}`, output: "get_prompt requires name." }
-              const result = await client.getPrompt({ name: args.name, arguments: parseMcpArguments(args.argumentsJson) }, requestOptions)
-              setOnDemandMcpHealth(args.server, "ready")
-              return { title: `Raven MCP: ${args.server}.${args.name}`, output: formatMcpResult(result) }
-            }
-
-            return { title: `Raven MCP: ${args.server}`, output: `Unsupported operation: ${operation}` }
-          } catch (err: any) {
-            if (!connected && !context.abort.aborted) {
-              const name = setOnDemandMcpHealth(args.server, "failed", err?.message ?? err)
-              if (name) await notifyIfMcpFailures([name])
-            }
-            return { title: `Raven MCP: ${args.server}`, output: `MCP call failed: ${err?.message ?? err}` }
-          } finally {
-            if (connection) {
-              connection.active = Math.max(0, connection.active - 1)
-              connection.lastUsed = Date.now()
-            }
-          }
-        },
-      }),
-    },
-
-    // Track agent ↔ session mapping for allowlist + Raven exclusion
-    async "chat.message"(input: any, _output: any) {
-      if (input.agent) {
-        sessionAgents.set(input.sessionID, input.agent)
-        if (input.agent === "raven") {
-          ravenSessions.add(input.sessionID)
-          ravenSessionKinds.set(input.sessionID, "seek")
-        } else if (input.agent === "raven-mcp") {
-          ravenSessions.add(input.sessionID)
-          ravenSessionKinds.set(input.sessionID, "mcp")
-        }
-      }
-    },
-
-    async event(input: { event: any }) {
-      // Track subagent session → parent mapping for accurate context counting
-      const evt = input.event
-      if (evt?.type === "session.created") {
-        const info = evt.properties?.info
-        if (info?.parentID && info?.id) ravenSessionParents.set(info.parentID, info.id)
-      }
-      if (evt?.type === "session.deleted") {
-        const sessionId = evt.properties?.info?.id
-        if (sessionId) {
-          ravenSessions.delete(sessionId)
-          ravenSessionKinds.delete(sessionId)
-          activeRavenPrompts.delete(sessionId)
-          sessionAgents.delete(sessionId)
-          clearRavenWaiters(sessionId)
-          for (const [parentId, childId] of ravenSessionParents) {
-            if (parentId === sessionId || childId === sessionId) ravenSessionParents.delete(parentId)
-          }
-          await closeMcpConnectionsForSession(sessionId)
-        }
-      }
-      if (evt?.type === "message.updated") {
-        const info = evt.properties?.info
-        if (info?.role === "assistant" && info?.sessionID && info.error && ravenSessions.has(info.sessionID)) {
-          reportRavenProviderError(info.sessionID, info.error)
-        }
-      }
-      if (evt?.type === "message.part.updated") {
-        const part = evt.properties?.part
-        if (part?.sessionID && ravenSessions.has(part.sessionID)) {
-          if (part.type === "retry" && part.error) {
-            reportRavenProviderError(part.sessionID, part.error)
-          } else {
-            reportRavenProgress(part.sessionID)
-          }
-        }
-      }
-      if (evt?.type === "session.status") {
-        const sessionId = evt.properties?.sessionID
-        const status = evt.properties?.status
-        if (sessionId && ravenSessions.has(sessionId)) {
-          if (status?.type === "retry") {
-            reportRavenProviderError(sessionId, { name: "RetryError", data: { message: status.message } })
-          }
-        }
-      }
-      if (evt?.type === "session.error") {
-        const sessionId = evt.properties?.sessionID
-        if (sessionId && evt.properties?.error && ravenSessions.has(sessionId)) {
-          reportRavenProviderError(sessionId, evt.properties.error)
-        }
-      }
-
-      if (updateToastPending) {
-        updateToastPending = false
-        setTimeout(() => void notifyIfUpdateAvailable(), 500)
-      }
-      if (mcpFailureToastPending) {
-        mcpFailureToastPending = false
-        void scheduleOnDemandMcpRefresh().then((result) => notifyIfMcpFailures(result.failed))
-      }
-      if (duplicateMcpToastPending) {
-        duplicateMcpToastPending = false
-        setTimeout(() => void notifyIfDuplicateMcps(), 700)
-      }
-    },
-
-    // /raven help|route|seek ...|mcp ...|update|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 === "help") {
-        output.parts.push({ type: "text", text: helpText() })
-      } else if (arg === "stats") {
-        output.parts.push({ type: "text", text: statsText() })
-      } 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 keyword add <keyword>\n  /raven route keyword remove <keyword>\n\nGlobal MCPs are auto-routed by detected OpenCode MCP server name.` })
-      } 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 === "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 keyword add <keyword>\n  /raven route keyword remove <keyword>\n\nGlobal MCPs are auto-routed by detected OpenCode MCP server name." })
-        } else {
-          updateConfig((latest) => {
-            const values = uniqueStrings(latest.raven_seek[key])
-            const exists = values.some((value) => value.toLowerCase() === name.toLowerCase())
-            const next = action === "add"
-              ? exists ? values : [...values, name]
-              : values.filter((value) => value.toLowerCase() !== name.toLowerCase())
-            return { raven_seek: key === "routeTools" ? { routeTools: next } : { routeToolKeywords: next } }
-          })
-          output.parts.push({ type: "text", text: routeSummary() })
-        }
-      } else if (arg.startsWith("seek ")) {
-        const parts = raw.split(/\s+/)
-        const action = parts[1]?.toLowerCase()
-        const value = parts.slice(2).join(" ").trim()
-        if (action === "model" && value) {
-          updateConfig({ raven_seek: { model: value } })
-          delete ravenProviderIssues.seek
-          output.parts.push({ type: "text", text: `Raven Search model set to: ${value}\nRestart opencode for the change to take effect.` })
-        } else if (action === "effort" && value) {
-          updateConfig({ raven_seek: { reasoning_effort: value } })
-          output.parts.push({ type: "text", text: `Raven Search reasoning effort set to: ${value}\nRestart opencode for the change to take effect.` })
-        } else if (action === "timeout") {
-          const seconds = Number(value)
-          if (!Number.isInteger(seconds) || seconds < 10 || seconds > MAX_TIMEOUT_SECONDS) {
-            output.parts.push({ type: "text", text: `Usage: /raven seek timeout <seconds>\nMust be between 10 and ${MAX_TIMEOUT_SECONDS}. Current: ${config.raven_seek.timeout ?? 600}s` })
-          } else {
-            updateConfig({ raven_seek: { timeout: seconds } })
-            output.parts.push({ type: "text", text: `Raven Search timeout set to ${seconds}s. Takes effect immediately.` })
-          }
-        } else {
-          output.parts.push({ type: "text", text: "Usage:\n  /raven seek model <provider/model>\n  /raven seek effort <value>\n  /raven seek timeout <seconds>" })
-        }
-      } else if (arg === "mcp") {
-        output.parts.push({ type: "text", text: `${onDemandMcpStatus()}\n\nUsage:\n  /raven mcp refresh [server_name]\n  /raven mcp detail full\n  /raven mcp detail minimized` })
-      } else if (arg.startsWith("mcp ")) {
-        const parts = raw.split(/\s+/)
-        const action = parts[1]?.toLowerCase()
-        if (action === "refresh") {
-          const serverName = parts.slice(2).join(" ").trim() || undefined
-          const result = await queueOnDemandMcpRefresh(true, serverName)
-          await notifyIfMcpFailures(result.failed)
-          output.parts.push({
-            type: "text",
-            text: `On-demand MCP refresh complete.\n  Refreshed: ${result.refreshed.length ? result.refreshed.join(", ") : "none"}\n  Failed: ${result.failed.length ? result.failed.join(", ") : "none"}`,
-          })
-        } else if (action === "detail") {
-          const detail = parts[2]?.toLowerCase()
-          if (detail !== "full" && detail !== "minimized") {
-            output.parts.push({ type: "text", text: `Usage: /raven mcp detail full|minimized\nCurrent: ${config.raven_mcp.descriptionDetail ?? "full"}` })
-          } else {
-            updateConfig({ raven_mcp: { descriptionDetail: detail } })
-            output.parts.push({ type: "text", text: `On-demand MCP guidance detail set to: ${detail}\nRestart opencode for startup instructions/tool descriptions to fully refresh.` })
-          }
-        } else if (action === "model" && parts.slice(2).join(" ").trim()) {
-          const model = parts.slice(2).join(" ").trim()
-          updateConfig({ raven_mcp: { model } })
-          delete ravenProviderIssues.mcp
-          output.parts.push({ type: "text", text: `Raven MCP model set to: ${model}\nRestart opencode for the change to take effect.` })
-        } else if (action === "effort" && parts.slice(2).join(" ").trim()) {
-          const effort = parts.slice(2).join(" ").trim()
-          updateConfig({ raven_mcp: { reasoning_effort: effort } })
-          output.parts.push({ type: "text", text: `Raven MCP reasoning effort set to: ${effort}\nRestart opencode for the change to take effect.` })
-        } else if (action === "timeout") {
-          const seconds = Number(parts[2])
-          if (!Number.isInteger(seconds) || seconds < 10 || seconds > MAX_TIMEOUT_SECONDS) {
-            output.parts.push({ type: "text", text: `Usage: /raven mcp timeout <seconds>\nMust be between 10 and ${MAX_TIMEOUT_SECONDS}. Current: ${config.raven_mcp.timeout ?? 600}s` })
-          } else {
-            updateConfig({ raven_mcp: { timeout: seconds } })
-            output.parts.push({ type: "text", text: `Raven MCP timeout set to ${seconds}s. Takes effect immediately.` })
-          }
-        } else {
-          output.parts.push({ type: "text", text: "Usage:\n  /raven mcp\n  /raven mcp refresh [server_name]\n  /raven mcp detail full|minimized\n  /raven mcp model <provider/model>\n  /raven mcp effort <value>\n  /raven mcp timeout <seconds>" })
-        }
-      } else if (arg === "update") {
-        try {
-          const info = await refreshUpdateInfo()
-          if (!info.latest) {
-            output.parts.push({ type: "text", text: `Could not check npm for ${PACKAGE_NAME}. Try again later.\n\n${manualUpdateText()}` })
-          } else if (!info.available) {
-            output.parts.push({ type: "text", text: `Raven is up to date (${info.current}). Latest on npm: ${info.latest}.` })
-          } else {
-            const removed = clearPluginCache()
-            output.parts.push({ type: "text", text: `Raven update available: ${info.current} → ${info.latest}.\n\nCleared ${removed.length} opencode plugin cache entr${removed.length === 1 ? "y" : "ies"}. ${manualUpdateText(info.latest)}` })
-          }
-        } catch (err: any) {
-          output.parts.push({ type: "text", text: `Raven update check failed: ${err?.message ?? err}\n\n${manualUpdateText()}` })
-        }
-      } else {
-        const seek = config.raven_seek
-        const mcp = config.raven_mcp
-        const seekIssue = ravenProviderIssues.seek ? `\n  Provider issue: ${ravenProviderIssues.seek}` : ""
-        const mcpIssue = ravenProviderIssues.mcp ? `\n  Provider issue: ${ravenProviderIssues.mcp}` : ""
-        let update = "Update: unable to check npm."
-        try {
-          const info = await getUpdateInfo()
-          update = info.available && info.latest
-            ? `Update: ${info.latest} available. Run /raven update, then restart opencode.`
-            : info.latest
-              ? `Update: up to date (latest ${info.latest}).`
-              : "Update: unable to check npm."
-        } catch { /* keep fallback */ }
-        output.parts.push({ type: "text", text: `Raven version: ${PACKAGE_VERSION}.\nSearch agent: ${seek.model || fm.model || "(default)"}. Reasoning: ${seek.reasoning_effort || fm.reasoning_effort || "(default)"}. Timeout: ${seek.timeout ?? 600}s.${seekIssue}\nMCP agent: ${mcp.model || mcpFm.model || "(default)"}. Reasoning: ${mcp.reasoning_effort || mcpFm.reasoning_effort || "(default)"}. Timeout: ${mcp.timeout ?? 600}s.${mcpIssue}\n${update}\n\n${routeSummary()}\n\n${mcpSummary()}\n\n${statsText()}\n\nRun /raven help for commands.` })
-      }
-    },
-
-    async "tool.execute.before"(input: any, output: any) {
-      if ((input.tool === "raven_seek" || input.tool === "raven_mcp") && ravenSessions.has(input.sessionID)) {
-        throw new Error(`${input.tool} cannot be called from inside a Raven agent. Use that agent's direct tools instead.`)
-      }
-
-      if (input.tool === "raven_mcp_bridge" && ravenSessionKinds.get(input.sessionID) !== "mcp" && sessionAgents.get(input.sessionID) !== "raven-mcp") {
-        throw new Error("raven_mcp_bridge is only available inside the Raven MCP agent. Use raven_mcp for on-demand MCP requests.")
-      }
-
-      if (ravenSessions.has(input.sessionID)) return
-      if (isExcluded(sessionAgents.get(input.sessionID))) return
-      if (config.raven_seek.excludeTools?.some((name) => name.toLowerCase() === input.tool.toLowerCase())) return
-
-      if (input.tool === "task" && output.args?.subagent_type === "raven") {
-        ravenTaskCalls.add(input.callID)
-      }
-
-      // ── 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))
-      }
-    },
-
-    async "tool.execute.after"(input: any, output: any) {
-      if (ravenTaskCalls.has(input.callID)) {
-        ravenTaskCalls.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 countRavenSavedCandidateBytes(ravenSessionId)
-            .then((total) => {
-              const saved = Math.max(0, total - String(output.output ?? "").length)
-              if (saved > 0) addBytes(saved)
-            })
-            .catch(() => {
-              // Without token metadata we cannot separate saved context from the compact answer.
-            })
-        }
-      }
-    },
-  }
-}) satisfies Plugin
+} satisfies V2Plugin.Plugin & { server: V1Plugin }