@hiai-gg/hiai-opencode 0.1.6 → 0.1.8

package/.env.example

@@ -24,6 +24,13 @@
 # Optional - Context7 code search MCP
 # CONTEXT7_API_KEY=your_context7_api_key_here
 
+# Optional - Exa remote websearch MCP. Recommended for higher limits.
+# EXA_API_KEY=your_exa_api_key_here
+
+# Optional - Tavily remote websearch MCP.
+# Required only when hiai-opencode.json uses provider "tavily".
+# TAVILY_API_KEY=your_tavily_api_key_here
+
 # Local Model Helpers
 
 # Optional - Ollama local model endpoint

package/AGENTS.md

@@ -115,6 +115,8 @@ When a user asks OpenCode or another agent to finish installing this plugin, fol
    - `FIRECRAWL_API_KEY`
    - `STITCH_AI_API_KEY`
    - `CONTEXT7_API_KEY`
+   - `EXA_API_KEY`
+   - `TAVILY_API_KEY`
    - `MEMPALACE_PYTHON`
    - `OPENCODE_RAG_URL`
    - `HIAI_PLAYWRIGHT_INSTALL_BROWSERS`
@@ -137,10 +139,13 @@ When a user asks OpenCode or another agent to finish installing this plugin, fol
 | `rag` | User has a local or remote RAG endpoint | Uses `OPENCODE_RAG_URL`, defaulting to `http://localhost:9002/tools/search` |
 | `stitch` | `STITCH_AI_API_KEY` is set | Remote MCP endpoint |
 | `context7` | User wants Context7 docs/search | Remote MCP endpoint; use `CONTEXT7_API_KEY` if available |
+| `websearch` | User wants remote web search | Defaults to Exa; `EXA_API_KEY` optional for Exa, `TAVILY_API_KEY` required for Tavily |
+| `grep_app` | User wants GitHub/code search | Remote MCP endpoint; no key required |
 
 Playwright troubleshooting rules:
 
-- If `skill_mcp` says `MCP server "playwright" not found`, first load the `playwright` skill and check `hiai-opencode mcp-status`; do not report this as a browser dependency failure.
+- `skill_mcp` can call enabled hiai-opencode builtin MCPs and skill-embedded MCPs. If it reports a builtin MCP such as `firecrawl` as missing, check that the installed plugin version includes builtin fallback support and that `hiai-opencode.json` has that MCP enabled.
+- If `skill_mcp` says `MCP server "playwright" not found`, first check `hiai-opencode mcp-status`; do not report this as a browser dependency failure.
 - If Chromium reports missing Linux libraries (`libnspr4`, `libnss3`, `libatk-bridge`, `libgtk-3`, etc.), explain that MCP is present but the host lacks browser system dependencies.
 - Without sudo, try a system browser override in `hiai-opencode.json`, such as `--browser chrome` or `--browser msedge`.
 - If no browser path works, use `curl` only as degraded HTTP verification and explicitly say it is not a replacement for browser testing.
@@ -166,6 +171,8 @@ Check which services can run here:
 - rag: OPENCODE_RAG_URL or http://localhost:9002/tools/search.
 - stitch: STITCH_AI_API_KEY.
 - context7: optional CONTEXT7_API_KEY.
+- websearch: optional EXA_API_KEY for Exa, or TAVILY_API_KEY when provider is tavily.
+- grep_app: no key required.
 
 Report missing keys without printing secret values. Never invent or hardcode API keys.
 
@@ -223,6 +230,7 @@ The runtime loader is:
 Users configure only the 10 primary agent model slots under `models`: `bob`, `coder`, `strategist`, `guard`, `critic`, `designer`, `researcher`, `manager`, `brainstormer`, and `vision`.
 Hidden agents and task categories are derived internally in `src/config/defaults.ts`.
 Use fully qualified model IDs. Do not introduce local aliases like `hiai-fast`, `sonnet`, `fast`, or `high`.
+When helping a user choose model IDs, tell them to connect providers in OpenCode, run `opencode models`, and copy the exact `provider/model-id` strings into `hiai-opencode.json`. Do not invent provider prefixes.
 
 ## Change Map
 
@@ -352,6 +360,41 @@ Current MCP set:
 - `websearch`
 - `grep_app`
 
+## Writing And Website Copy
+
+Public-facing website/product copy is owned by `brainstormer`.
+`writer`, `copywriter`, `content-writer`, and `website-writer` are aliases for `brainstormer`.
+
+Use the `website-copywriting` skill for:
+
+- landing pages
+- hero sections
+- CTA labels
+- feature copy
+- positioning and naming
+- onboarding, empty states, and product microcopy
+
+Preferred invocation:
+
+```text
+task(subagent_type="brainstormer", load_skills=["website-copywriting"], run_in_background=false, description="Write landing page copy", prompt="...")
+```
+
+Use `designer` or `visual-engineering` for visual direction. Use `brainstormer` for words.
+
+## Manager Memory Stewardship
+
+Use `platform-manager` / `manager` when durable project memory or handoff state must stay current.
+
+Manager owns:
+
+- MemPalace decision hygiene: search first, deduplicate, write only durable decisions and important preferences.
+- Architecture memory updates: when architecture changes, update MemPalace and sync to RAG only if the configured RAG endpoint exposes write/upsert capability.
+- TODO hygiene: mark completed items complete, preserve unfinished tasks with blocker and next action, remove duplicate stale TODOs.
+- Session continuity: write concise handoff ledgers, not raw transcripts.
+
+Do not ask Manager to implement code. Use Coder for implementation and Manager for memory/task state.
+
 ## Skill Discovery Rules
 
 Default behavior is intentionally deterministic.
@@ -404,6 +447,8 @@ Common service keys:
 - `STITCH_AI_API_KEY`
 - `FIRECRAWL_API_KEY`
 - `CONTEXT7_API_KEY`
+- `EXA_API_KEY`
+- `TAVILY_API_KEY`
 - `OLLAMA_BASE_URL`
 - `OLLAMA_MODEL`
 - `MEMPALACE_PYTHON`
@@ -415,6 +460,41 @@ Common service keys:
 - `HIAI_OPENCODE_MCP_EXPORT_PATH`
 - `HIAI_OPENCODE_EXPORT_MCP_MODE`
 
+## Mental Map
+
+Agent/MCP/LSP integration reference — which agents use which integrations:
+
+```
+AGENTS:
+  bob (you)        — orchestrator
+  coder            — implementation (deep)
+  sub              — implementation (cheap, bounded)
+  strategist       — planning (read-only, no code)
+  critic           — review gate (APPROVED/REJECTED)
+  researcher       — discovery: local grep + Context7/Firecrawl/grep_app/websearch/RAG/MemPalace
+  designer         — UI via Stitch MCP
+  brainstormer     — copy/positioning/SEO (write to copy files only)
+  vision           — PDF/image extraction
+  manager          — MemPalace/RAG memory steward
+  quality-guardian — post-impl review + bug investigation
+  guard            — sandboxed bash executor
+
+MCP INTEGRATIONS (who uses what):
+  Stitch              -> designer (UI generation)
+  Firecrawl           -> researcher (web scrape/search/extract)
+  Context7            -> researcher, coder (lib docs)
+  grep_app            -> researcher (OSS code patterns)
+  websearch           -> researcher (general web)
+  RAG                 -> researcher, brainstormer, manager (project knowledge)
+  MemPalace           -> manager (primary), all agents (search before answer)
+  Sequential-Thinking -> strategist, critic (deep reasoning)
+  Playwright          -> coder (only for tests/automation)
+
+LSP:
+  typescript, svelte, eslint, bash, pyright
+  -> coder MUST run lsp_diagnostics after every edit
+```
+
 ## Known Runtime Caveats
 
 Windows/OpenCode may fail to spawn local MCP processes with `EPERM` for `cmd` or `node`. When that happens:

package/ARCHITECTURE.md

@@ -12,6 +12,45 @@ The plugin has five main layers:
 4. MCP and LSP wiring
 5. migration and compatibility handling
 
+## Request Flow
+
+```
+User input
+    │
+    ▼
+┌─────────┐
+│   Bob    │ ← orchestrator / router
+└────┬────┘
+     │ delegates
+     ▼
+┌──────────────────────────────────────────────────────┐
+│                                                      │
+│  researcher ◄── background (facts, docs)             │
+│  strategist ◄── planning (plan before action)        │
+│                                                      │
+│  category routes to:                                  │
+│    deep/ultrabrain → coder (implementation)           │
+│    quick/bounded    → sub (cheap bounded)            │
+│    writing         → brainstormer (copy)            │
+│    visual-engineering → designer (Stitch MCP)       │
+│    artistry       → designer (creative)             │
+│                                                      │
+└──────────────────────────────────────────────────────┘
+     │
+     ▼
+┌─────────┐
+│   Bob    │ ← collects results, verifies
+└────┬────┘
+     │
+     ▼
+  User response
+```
+
+**Key wiring rules:**
+- OpenCode plugins are NOT MCP servers. `hiai-opencode` only provides the OpenCode-side launch wiring for MCP servers through its `mcp` config and helper launchers in `assets/mcp/`.
+- Model credentials go through OpenCode Connect, not `hiai-opencode.json`.
+- Service keys (`FIRECRAWL_API_KEY`, `STITCH_AI_API_KEY`, etc.) go in `hiai-opencode.json` `mcp` section or as env vars.
+
 ## Repository Layout
 
 - [src/config](src/config): schemas, types, and bundled config loading
@@ -89,10 +128,13 @@ Prompting is not a single file and not a single directory. `src/agents` is the m
 These files create the top-level agent config objects:
 
 - Bob: [src/agents/bob.ts](src/agents/bob.ts)
-- Coder: `src/agents/coder/agent.ts`
+- Coder: [src/agents/coder/agent.ts](src/agents/coder/agent.ts)
 - Strategist: `src/agents/strategist/*`
-- Guard: `src/agents/guard/agent.ts`
-- Critic: `src/agents/critic/agent.ts`
+- Guard: [src/agents/guard/agent.ts](src/agents/guard/agent.ts)
+- Critic: [src/agents/critic/agent.ts](src/agents/critic/agent.ts)
+- Designer: [src/agents/designer.ts](src/agents/designer.ts)
+- Brainstormer: [src/agents/brainstormer.ts](src/agents/brainstormer.ts)
+- Agent Skills: [src/agents/agent-skills.ts](src/agents/agent-skills.ts)
 - Vision: [src/agents/ui.ts](src/agents/ui.ts)
 - Manager: [src/agents/platform-manager.ts](src/agents/platform-manager.ts)
 - Researcher: [src/agents/researcher.ts](src/agents/researcher.ts)

package/README.md

@@ -1,15 +1,18 @@
 # hiai-opencode
 
-`hiai-opencode` is an OpenCode plugin that wires together:
+[![CI](https://github.com/HiAi-gg/hiai-opencode/actions/workflows/ci.yml/badge.svg)](https://github.com/HiAi-gg/hiai-opencode/actions/workflows/ci.yml)
 
-- a curated multi-agent runtime
-- project and OpenCode skills
-- MCP integrations
-- LSP defaults
-- migration and compatibility wiring
+`hiai-opencode` is an OpenCode plugin that turns vanilla OpenCode into an opinionated multi-agent cockpit.
 
-This repository is intended to be usable by someone who clones it from GitHub without any internal context.
-The external MCP servers, skills, model providers, and auxiliary OpenCode plugins remain their own upstream projects; this plugin only provides OpenCode wiring, defaults, prompts, launchers, and documentation around them.
+**What you get on top of plain OpenCode:**
+
+- **12-agent canonical model** with peer-aware prompts — Bob orchestrates, Coder/Sub implement, Strategist plans, Critic gates, Researcher discovers via Context7/Firecrawl/grep_app/RAG/MemPalace, Designer drives Stitch UI generation, Brainstormer owns copy/SEO, Vision extracts PDFs/images, Manager keeps memory, Quality Guardian reviews, Guard sandboxes bash.
+- **Mode → agent routing** for `task()` delegation — `quick`/`bounded`/`unspecified-low` → Sub, `deep`/`cross-module` → Coder, `ultrabrain` → Strategist, `visual-engineering`/`artistry` → Designer, `writing` → Brainstormer, `git-ops` → Manager. No more "everything routes to coder".
+- **MCP wiring out of the box** — Stitch, Firecrawl, Context7, grep_app, websearch, RAG, MemPalace, Sequential-Thinking, Playwright. Each agent's prompt knows which MCP servers it owns.
+- **LSP defaults** for TypeScript, Svelte, ESLint, Bash, Pyright. Coder must run `lsp_diagnostics` after every edit.
+- **Permission discipline** — read-only agents cannot delegate; write-capable agents have explicit file-scope limits.
+
+This repository is intended to be usable by someone who clones it from GitHub without any internal context. External MCP servers, skills, model providers, and auxiliary OpenCode plugins remain their own upstream projects; this plugin only provides OpenCode wiring, defaults, prompts, launchers, and documentation around them.
 
 ## Why This Exists
 
@@ -36,16 +39,61 @@ Then run `hiai-opencode doctor`, `hiai-opencode mcp-status`, and `opencode debug
 
 For the full operator playbook, see [AGENTS.md](AGENTS.md). 🤖
 
+## Agents
+
+| Agent | Role | When to use |
+|-------|------|-------------|
+| `Bob` | Orchestrator, router, distributor | Entry point; complex tasks needing multi-agent coordination |
+| `Coder` | Deep implementation, focused execution | Complex features, refactors, deep work |
+| `Sub` | Bounded cheap executor | Small targeted changes, quick fixes |
+| `Strategist` | Planning, architecture, pre-check | Scope definition, architectural decisions |
+| `Guard` | Final acceptor, workflow enforcer | Closure validation, output acceptance |
+| `Critic` | Review gate, high-accuracy verification | Plan review, code review, regression catch |
+| `Researcher` | Local + external search | Codebase exploration, documentation discovery |
+| `Designer` | UI/visual, creative direction | Visual problems, UX decisions, branding |
+| `Brainstormer` | Ideation, content, copy | Landing pages, CTA, feature copy, onboarding |
+| `Vision` | Image/PDF/layout analysis | Visual inspection, multimodal interpretation |
+| `Manager` | Memory, bootstrap, ledger | Durable state, session continuity, project init |
+
+## Modes (Task Routing)
+
+Mode determines prompt append, variant, and reasoning effort. The executor agent is selected via `mode → agent` mapping.
+
+| Mode | Agent | Prompt variant | When to use |
+|------|-------|----------------|-------------|
+| `quick` | `sub` | Fast bounded | Small targeted changes |
+| `writing` | `brainstormer` | Docs/prose | Content, i18n, copy |
+| `deep` | `coder` | Deep reasoning | Complex implementation |
+| `ultrabrain` | `strategist` | Plan-only | Architecture, hard logic |
+| `visual-engineering` | `designer` | UI/visual | Visual problems |
+| `artistry` | `designer` | Creative | Brand, SEO, creative |
+| `git` | `platform-manager` | Git ops | Version control operations |
+| `bounded` | `sub` | Mid-tier bounded | Moderate effort changes |
+| `cross-module` | `coder` | Deep substantial | Multi-component changes |
+| `unspecified-low` | `sub` | Bounded | Unclassified small tasks |
+| `unspecified-high` | `coder` | Deep | Unclassified substantial tasks |
+
+## Integrations
+
+MCP integrations and which agents use them:
+
+| Service | Key env var | Agent(s) | What it's for |
+|---------|------------|----------|---------------|
+| Stitch | `STITCH_AI_API_KEY` | Designer | UI generation, design systems, screen variants |
+| Firecrawl | `FIRECRAWL_API_KEY` | Researcher | Web scraping, crawl, extract, search |
+| Context7 | `CONTEXT7_API_KEY` | Researcher, Coder | Library API documentation |
+| grep_app | — | Researcher | GitHub OSS code pattern search |
+| websearch (Exa) | `EXA_API_KEY` | Researcher | General web search |
+| websearch (Tavily) | `TAVILY_API_KEY` | Researcher | General web search (alt provider) |
+| RAG | `OPENCODE_RAG_URL` | Researcher, Brainstormer, Manager | Project knowledge base |
+| MemPalace | — | Manager (primary), all agents | Project memory and past decisions |
+| Sequential-Thinking | — | Strategist, Critic | Deep reasoning for planning/review |
+| Playwright | — | Coder | Browser tests and automation |
+
 ## What You Get
 
-- Visible primary agents: `Bob`, `Coder`, `Strategist`, `Guard`, `Critic`, `Designer`, `Researcher`, `Manager`, `Brainstormer`, `Vision`
-- Hidden system or compatibility agents: `Agent Skills`, `Sub`, `build`, `plan`
-- Task routing model:
-  - category-based execution routes through `Coder`
-  - `quick`, `writing`, and `unspecified-low` are the fast bounded Coder contour
-  - `deep`, `ultrabrain`, `visual-engineering`, `artistry`, and `unspecified-high` are the deep Coder contour
-  - `Critic` and `Researcher` are selected explicitly
-  - `Designer`, `Brainstormer`, `Manager`, and `Vision` are direct callable specialists
+- **10 visible primary agents** + **4 hidden system agents** (Agent Skills, Sub, build, plan)
+- **Mode-based task routing** via `task(category=..., ...)` or `task(mode=..., ...)`
 - Skill materialization into OpenCode's `skills/` view
 - MCP wiring for `playwright`, `stitch`, `sequential-thinking`, `firecrawl`, `rag`, `mempalace`, `context7`, plus remote `websearch` and `grep_app`
 - LSP wiring for TypeScript, Svelte, Python, Bash, and ESLint
@@ -67,6 +115,8 @@ Optional, depending on which services you want:
 - `FIRECRAWL_API_KEY` for Firecrawl
 - `STITCH_AI_API_KEY` for Stitch
 - `CONTEXT7_API_KEY` for Context7
+- `EXA_API_KEY` for higher Exa websearch limits
+- `TAVILY_API_KEY` when `mcp.websearch.provider` is `tavily`
 - Python 3.9+ or `uv` for MemPalace
 - a running RAG endpoint if you enable `rag`
 - local language servers if you want LSP beyond the npm-bootstrapped helpers
@@ -153,10 +203,19 @@ This plugin only reads the 10 model IDs in `models`. Internal routing derives hi
 
 Use OpenCode Connect to authorize the providers behind your configured model IDs. Then add only the service keys for MCP or search integrations you actually use:
 
+```bash
+opencode models
+```
+
+Use the exact model IDs printed by OpenCode in `hiai-opencode.json`. For example, `openrouter/minimax/minimax-m2.7` routes through OpenRouter, while `minimax/minimax-m2.7` routes through a direct Minimax provider only if that provider is connected in OpenCode.
+
 ```bash
 export FIRECRAWL_API_KEY=...
 export STITCH_AI_API_KEY=...
 export CONTEXT7_API_KEY=...
+export EXA_API_KEY=...
+# or, if mcp.websearch.provider is "tavily":
+export TAVILY_API_KEY=...
 ```
 
 See [Environment Variables And Keys](#environment-variables-and-keys) for the full list.
@@ -245,6 +304,7 @@ Runtime loader for the bundled canonical config:
 If you want to change model selection, edit the 10 entries in `models`. Do not add category-specific model choices unless you are intentionally developing the plugin internals.
 
 Use fully qualified model IDs. Do not introduce local aliases like `hiai-fast`, `sonnet`, `fast`, or `high`.
+After connecting providers in OpenCode, run `opencode models` and copy the exact model IDs from that output into `hiai-opencode.json`.
 
 ### Prompting
 
@@ -263,6 +323,7 @@ Important prompt entrypoints:
 - `Vision`: [src/agents/ui.ts](src/agents/ui.ts)
 - `Manager`: [src/agents/platform-manager.ts](src/agents/platform-manager.ts)
 - `Researcher`: [src/agents/researcher.ts](src/agents/researcher.ts)
+- `Brainstormer` / `Writer`: [src/agents/brainstormer.ts](src/agents/brainstormer.ts)
 
 Name mapping and visibility:
 
@@ -279,6 +340,22 @@ Skill materialization logic:
 
 - [src/features/builtin-skills/materialize.ts](src/features/builtin-skills/materialize.ts)
 
+Built-in helper skills include browser automation, frontend UI/UX, review, git workflow, hiai-opencode setup, AI slop cleanup, and `website-copywriting`.
+
+Website/product copy should use:
+
+```text
+task(subagent_type="brainstormer", load_skills=["website-copywriting"], ...)
+```
+
+`writer`, `copywriter`, and `content-writer` are aliases for `brainstormer`.
+
+Manager memory stewardship:
+
+- Use `task(subagent_type="platform-manager", ...)` or `task(subagent_type="manager", ...)` for MemPalace cleanup, session ledgers, TODO hygiene, and architecture decision handoff.
+- Manager writes only durable decisions and important project state. It should not dump raw chat logs into memory.
+- RAG is retrieval-first by default; Manager syncs architecture summaries to RAG only when the configured endpoint exposes write/upsert capability.
+
 Skill discovery defaults:
 
 ```json
@@ -327,6 +404,8 @@ Important service variables:
 - `STITCH_AI_API_KEY`
 - `FIRECRAWL_API_KEY`
 - `CONTEXT7_API_KEY`
+- `EXA_API_KEY`
+- `TAVILY_API_KEY`
 - `OLLAMA_BASE_URL`
 - `OLLAMA_MODEL`
 - `MEMPALACE_PYTHON`
@@ -349,7 +428,9 @@ The user-facing MCP switchboard is the `mcp` object in `hiai-opencode.json`:
 {
   "mcp": {
     "playwright": { "enabled": true },
-    "mempalace": { "enabled": false }
+    "mempalace": { "enabled": false },
+    "websearch": { "enabled": true, "provider": "exa" },
+    "grep_app": { "enabled": true }
   }
 }
 ```
@@ -360,7 +441,7 @@ The source of truth for default MCP wiring is `src/mcp/registry.ts`. Change that
 
 - `stitch`
 - `context7`
-- `websearch`
+- `websearch`: defaults to Exa remote MCP. `EXA_API_KEY` is optional for Exa; set `"provider": "tavily"` and `TAVILY_API_KEY` to use Tavily.
 - `grep_app`
 
 ### Works with local helper bootstrap

package/assets/cli/hiai-opencode.mjs

@@ -61,11 +61,13 @@ Usage:
   hiai-opencode doctor
   hiai-opencode mcp-status
   hiai-opencode export-mcp [path]
+  hiai-opencode diagnose [path]
 
 Commands:
   doctor       Full install/runtime diagnostic: MCP status + static export freshness + provider/skills/agents/LSP checks + MCP tool probes.
   mcp-status   Check hiai-opencode MCP configuration, keys, and local runtimes.
   export-mcp   Write a static .mcp.json for hosts whose mcp list ignores plugin runtime MCP.
+  diagnose     Collect full diagnostic bundle to file (local only, no remote sending).
 `)
 }
 
@@ -826,6 +828,77 @@ async function mcpStatus(options = {}) {
   }
 }
 
+async function runDiagnose(outputPath) {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-")
+  const defaultPath = outputPath
+    || join(process.cwd(), `hiai-diagnose-${timestamp}.txt`)
+  const { path: configPath, config, error } = loadConfig()
+  const sections = []
+
+  sections.push("=".repeat(60))
+  sections.push(`hiai-opencode diagnose - ${timestamp}`)
+  sections.push("=".repeat(60))
+  sections.push("")
+
+  sections.push("ENVIRONMENT (keys only, no values):")
+  const envKeys = [
+    "FIRECRAWL_API_KEY", "STITCH_AI_API_KEY", "CONTEXT7_API_KEY",
+    "EXA_API_KEY", "TAVILY_API_KEY", "OPENCODE_RAG_URL",
+    "MEMPALACE_PYTHON", "HIAI_PLAYWRIGHT_INSTALL_BROWSERS", "HIAI_MCP_AUTO_INSTALL",
+  ]
+  for (const key of envKeys) {
+    const hasValue = !!process.env[key]?.trim()
+    sections.push(`  ${key}: ${hasValue ? "(set)" : "(not set)"}`)
+  }
+  sections.push("")
+
+  sections.push("CONFIGURATION:")
+  sections.push(`  Config path: ${configPath ?? "(defaults)"}`)
+  if (error) sections.push(`  Config parse warning: ${error}`)
+  const modelKeys = Object.keys(config?.models ?? {})
+  const mcpKeys = Object.keys(config?.mcp ?? {})
+  sections.push(`  models configured: ${modelKeys.length} [${modelKeys.join(", ") || "none"}]`)
+  sections.push(`  mcp servers in config: ${mcpKeys.length} [${mcpKeys.join(", ") || "none"}]`)
+  sections.push("")
+
+  sections.push("TOOLS REGISTERED:")
+  const toolCount = 26
+  sections.push(`  ~${toolCount} tools (from tool-registry.ts)`)
+  sections.push("")
+
+  sections.push("AGENTS:")
+  const agents = ["bob", "coder", "strategist", "guard", "critic", "designer", "researcher", "manager", "brainstormer", "vision"]
+  for (const agent of agents) {
+    const model = config?.models?.[agent]?.model
+    sections.push(`  ${agent}: ${model ? `model=${model}` : "(default)"}`)
+  }
+  sections.push("")
+
+  sections.push("MCP SERVERS:")
+  for (const [name, entry] of Object.entries(MCP_REGISTRY)) {
+    const userEntry = config?.mcp?.[name]
+    const enabled = userEntry?.enabled ?? entry.defaultEnabled
+    sections.push(`  ${name}: ${enabled ? "enabled" : "disabled"}`)
+  }
+  sections.push("")
+
+  sections.push("FILE PATHS:")
+  sections.push(`  CWD: ${process.cwd()}`)
+  sections.push(`  Package root: ${PACKAGE_ROOT}`)
+  sections.push(`  Config: ${configPath ?? "(none)"}`)
+  sections.push(`  Static MCP: ${join(process.cwd(), ".mcp.json")}`)
+  sections.push("")
+
+  sections.push("=".repeat(60))
+  sections.push("Diagnose complete. File written to: " + defaultPath)
+  sections.push("NO secrets or API keys are included in this output.")
+  sections.push("=".repeat(60))
+
+  mkdirSync(dirname(defaultPath), { recursive: true })
+  writeFileSync(defaultPath, sections.join("\n") + "\n")
+  console.log(`Diagnose written to: ${defaultPath}`)
+}
+
 async function main() {
   const command = process.argv[2]
   if (!command || command === "-h" || command === "--help") {
@@ -848,6 +921,11 @@ async function main() {
     return
   }
 
+  if (command === "diagnose") {
+    await runDiagnose(process.argv[3])
+    return
+  }
+
   console.error(`Unknown command: ${command}`)
   usage()
   process.exit(1)

package/config/hiai-opencode.schema.json

@@ -52,7 +52,9 @@
         "firecrawl": { "$ref": "#/definitions/toggle" },
         "rag": { "$ref": "#/definitions/toggle" },
         "mempalace": { "$ref": "#/definitions/mempalaceToggle" },
-        "context7": { "$ref": "#/definitions/toggle" }
+        "context7": { "$ref": "#/definitions/toggle" },
+        "websearch": { "$ref": "#/definitions/websearchToggle" },
+        "grep_app": { "$ref": "#/definitions/toggle" }
       }
     },
     "lsp": {
@@ -123,6 +125,19 @@
       },
       "required": ["enabled"],
       "additionalProperties": false
+    },
+    "websearchToggle": {
+      "type": "object",
+      "properties": {
+        "enabled": { "type": "boolean", "default": true },
+        "provider": {
+          "enum": ["exa", "tavily"],
+          "default": "exa",
+          "description": "Remote web search MCP provider. Exa works without an API key but can use EXA_API_KEY. Tavily requires TAVILY_API_KEY."
+        }
+      },
+      "required": ["enabled"],
+      "additionalProperties": false
     }
   }
 }

package/dist/agents/agent-skills.d.ts

@@ -0,0 +1,7 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AgentPromptMetadata } from "./types";
+export declare function createAgentSkillsAgent(model: string): AgentConfig;
+export declare namespace createAgentSkillsAgent {
+    var mode: "subagent";
+}
+export declare const agentSkillsPromptMetadata: AgentPromptMetadata;

package/dist/agents/brainstormer.d.ts

@@ -0,0 +1,7 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AgentPromptMetadata } from "./types";
+export declare function createBrainstormerAgent(model: string): AgentConfig;
+export declare namespace createBrainstormerAgent {
+    var mode: "subagent";
+}
+export declare const brainstormerPromptMetadata: AgentPromptMetadata;

package/dist/agents/coder/agent.d.ts

@@ -1,8 +1,8 @@
 import type { AgentConfig } from "@opencode-ai/sdk";
 import type { AgentPromptMetadata } from "../types";
 import type { AvailableAgent, AvailableTool, AvailableSkill, AvailableCategory } from "../dynamic-agent-prompt-builder";
-export type CoderPromptSource = "gpt-pro" | "gpt-codex" | "gpt";
-export declare function getCoderPromptSource(model?: string): CoderPromptSource;
+export type CoderPromptSource = "default";
+export declare function getCoderPromptSource(_model?: string): CoderPromptSource;
 export interface CoderContext {
     model?: string;
     availableAgents?: AvailableAgent[];

package/dist/agents/coder/gpt.d.ts

@@ -1,3 +1,4 @@
-/** Generic GPT Coder prompt - fallback for GPT models without a model-specific variant */
+/** PROMPT_VERSION: 2026-04-26
+ * Generic GPT Coder prompt - fallback for GPT models without a model-specific variant */
 import type { AvailableAgent, AvailableTool, AvailableSkill, AvailableCategory } from "../dynamic-agent-prompt-builder";
 export declare function buildCoderPrompt(availableAgents?: AvailableAgent[], availableTools?: AvailableTool[], availableSkills?: AvailableSkill[], availableCategories?: AvailableCategory[], useTaskSystem?: boolean): string;

package/dist/agents/designer.d.ts

@@ -0,0 +1,7 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AgentPromptMetadata } from "./types";
+export declare function createDesignerAgent(model: string): AgentConfig;
+export declare namespace createDesignerAgent {
+    var mode: "subagent";
+}
+export declare const designerPromptMetadata: AgentPromptMetadata;

package/dist/agents/dynamic-agent-core-sections.d.ts

@@ -11,7 +11,9 @@ export declare function buildKeyTriggersSection(agents: AvailableAgent[], _skill
 export declare function buildToolSelectionTable(agents: AvailableAgent[], tools?: AvailableTool[], _skills?: AvailableSkill[], options?: {
     includeIntegrationPrimer?: boolean;
 }): string;
-export declare function buildHiaiIntegrationPrimerSection(): string;
+export declare function buildHiaiIntegrationPrimerSection(options?: {
+    includeMentalMap?: boolean;
+}): string;
 export declare function buildResearcherSection(agents: AvailableAgent[]): string;
 export declare function buildDelegationTable(agents: AvailableAgent[]): string;
 export declare function buildStrategistAndCriticSection(agents: AvailableAgent[]): string;

package/dist/agents/guard/agent.d.ts

@@ -2,32 +2,21 @@
  * Guard - Master Orchestrator Agent
  *
  * Orchestrates work via task() to complete ALL tasks in a todo list until fully done.
- * You are the conductor of a symphony of specialized agents.
- *
- * Routing:
- * 1. GPT models (openai/*, github-copilot/gpt-*) → gpt.ts (GPT-5.4 optimized)
- * 2. Gemini models (google/*, google-vertex/*) → gemini.ts (Gemini-optimized)
- * 3. Default (Claude, etc.) → default.ts (Claude-optimized)
+ * Single unified prompt across all models.
  */
 import type { AgentConfig } from "@opencode-ai/sdk";
 import type { AgentPromptMetadata } from "../types";
 import type { AvailableAgent, AvailableSkill } from "../dynamic-agent-prompt-builder";
 import type { CategoryConfig } from "../../config/schema";
-export type GuardPromptSource = "default" | "gpt" | "gemini";
-/**
- * Determines which Guard prompt to use based on model.
- */
-export declare function getGuardPromptSource(model?: string): GuardPromptSource;
+export type GuardPromptSource = "default";
+export declare function getGuardPromptSource(_model?: string): GuardPromptSource;
 export interface OrchestratorContext {
     model?: string;
     availableAgents?: AvailableAgent[];
     availableSkills?: AvailableSkill[];
     userCategories?: Record<string, CategoryConfig>;
 }
-/**
- * Gets the appropriate Guard prompt based on model.
- */
-export declare function getGuardPrompt(model?: string): string;
+export declare function getGuardPrompt(_model?: string): string;
 export declare function createGuardAgent(ctx: OrchestratorContext): AgentConfig;
 export declare namespace createGuardAgent {
     var mode: "primary";

package/dist/agents/prompt-library/index.d.ts

@@ -5,3 +5,4 @@ export * from "./strategy";
 export * from "./platform";
 export * from "./intent-gate";
 export { buildAntiPatternsSection } from "../dynamic-agent-policy-sections";
+export { buildIntegrationMentalMap } from "./integration-map";

package/dist/agents/prompt-library/integration-map.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Integration Mental Map — shared source of truth for agent/MCP/LSP integration knowledge.
+ *
+ * Provides a concise reference of which agents use which MCP integrations,
+ * what LSP languages are available, and how the system is wired together.
+ *
+ * Used by Bob (orchestrator) and injected into the hiai-opencode integration primer.
+ */
+export declare function buildIntegrationMentalMap(): string;