oh-my-opencode-slim 0.3.5 → 0.3.7

package/README.md

@@ -12,7 +12,7 @@
 
 > Slimmed-down fork of [oh-my-opencode](https://github.com/code-yeongyu/oh-my-opencode) - focused on core agent orchestration without the extra bells and whistles.
 
-> **[Antigravity](https://antigravity.ai) subscription recommended.** The pantheon is tuned for Antigravity's model routing. Other providers work, but you'll get the best experience with Antigravity.
+> **[Antigravity](https://antigravity.google) subscription recommended.** The pantheon is tuned for Antigravity's model routing. Other providers work, but you'll get the best experience with Antigravity.
 
 ---
 
@@ -23,24 +23,14 @@
   - [For LLM Agents](#for-llm-agents)
 - [🏗️ **Architecture & Flow**](#architecture--flow)
 - [🏛️ **Meet the Pantheon**](#meet-the-pantheon)
-  - [Orchestrator](#orchestrator)
-  - [Explorer](#explorer)
-  - [Oracle](#oracle)
-  - [Librarian](#librarian)
-  - [Frontend Designer](#frontend-designer)
-  - [Document Writer](#document-writer)
-  - [Multimodal Viewer](#multimodal-viewer)
-  - [Code Simplifier](#code-simplifier)
 - [🛠️ **Tools & Capabilities**](#tools--capabilities)
-  - [Tmux Integration](#tmux-integration)
-  - [Quota Tool](#quota-tool)
-  - [Background Tasks](#background-tasks)
-  - [LSP Tools](#lsp-tools)
-  - [Code Search Tools](#code-search-tools)
 - [🧩 **Skills**](#-skills)
-  - [Playwright Integration](#playwright-integration)
-- [🔌 **MCP Servers**](#mcp-servers)
-- [⚙️ **Configuration**](#configuration)
+- [⚙️ **Configuration Guide**](#configuration-guide)
+  - [Locations & Precedence](#locations--precedence)
+  - [General Settings](#general-settings)
+  - [Agent Configuration](#agent-configuration)
+  - [Tmux Setup](#tmux-setup)
+  - [MCP Management](#mcp-management)
 - [🗑️ **Uninstallation**](#uninstallation)
 
 ---
@@ -350,71 +340,6 @@ Identify unnecessary complexity, challenge premature abstractions, estimate LOC
 - **Auto-Cleanup**: Panes close when agents finish, layout rebalances
 - **Zero Overhead**: Works with OpenCode's built-in `task` tool AND our `background_task` tool
 
-#### Quick Setup
-
-**1. Enable the OpenCode HTTP server** (one-time setup)
-
-Add to your `~/.config/opencode/opencode.json`:
-
-```json
-{
-  "server": {
-    "port": 4096
-  }
-}
-```
-
-**2. Enable tmux integration in the plugin**
-
-Add to your `~/.config/opencode/oh-my-opencode-slim.json`:
-
-```json
-{
-  "tmux": {
-    "enabled": true,
-    "layout": "main-vertical",
-    "main_pane_size": 60
-  }
-}
-```
-
-**3. Run OpenCode inside tmux**
-
-```bash
-tmux
-opencode
-```
-
-That's it. When agents spawn, they'll appear in new panes.
-
-#### Layout Options
-
-| Layout | Description |
-|--------|-------------|
-| `main-vertical` | Your session on the left (60%), agents stacked on the right |
-| `main-horizontal` | Your session on top (60%), agents stacked below |
-| `tiled` | All panes in equal-sized grid |
-| `even-horizontal` | All panes side by side |
-| `even-vertical` | All panes stacked vertically |
-
-#### Configuration Reference
-
-```json
-{
-  "tmux": {
-    "enabled": true,
-    "layout": "main-vertical",
-    "main_pane_size": 60
-  }
-}
-```
-
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `enabled` | boolean | `false` | Enable/disable tmux integration |
-| `layout` | string | `"main-vertical"` | Tmux layout preset |
-| `main_pane_size` | number | `60` | Size of main pane as percentage (20-80) |
-
 ---
 
 ### Quota Tool
@@ -431,7 +356,6 @@ For Antigravity users. You can trigger this at any time by asking the agent to *
 
 ### Background Tasks
 
-
 The plugin provides tools to manage asynchronous work:
 
 | Tool | Description |
@@ -487,60 +411,124 @@ Skills are specialized capabilities that combine MCP servers with specific instr
 
 ---
 
-## MCP Servers
+## ⚙️ Configuration Guide
 
-Built-in Model Context Protocol servers (enabled by default):
+The Pantheon listens to your commands through sacred JSON scriptures. Here is how you shape their behavior.
 
-| MCP | Purpose | URL |
-|-----|---------|-----|
-| `websearch` | Real-time web search via Exa AI | `https://mcp.exa.ai/mcp` |
-| `context7` | Official library documentation | `https://mcp.context7.com/mcp` |
-| `grep_app` | GitHub code search via grep.app | `https://mcp.grep.app` |
+### Locations & Precedence
+
+The plugin merges configuration from two locations. Settings in the **Project Local** file override those in the **User Global** file.
+
+| Level | Path | Scope |
+| :--- | :--- | :--- |
+| **User Global** | `~/.config/opencode/oh-my-opencode-slim.json` | All projects for this user |
+| **Project Local** | `./.opencode/oh-my-opencode-slim.json` | This specific repository |
+
+> **Note for Windows Users:** The global config is located at `%APPDATA%\opencode\oh-my-opencode-slim.json` or `~/.config/opencode/oh-my-opencode-slim.json`.
 
-### Disabling MCPs
+---
+
+### General Settings
 
-You can disable specific MCP servers in your config:
+#### OpenCode Server
+To enable certain integrations (like Tmux), you must first enable the OpenCode HTTP server in your main `opencode.json` file.
 
+**File:** `~/.config/opencode/opencode.json`
 ```json
 {
-  "disabled_mcps": ["websearch", "grep_app"]
+  "server": {
+    "port": 4096
+  }
 }
 ```
 
 ---
 
-## Configuration
+### Agent Configuration
+
+You can customize the underlying LLM and reasoning effort for each deity in the Pantheon.
+
+**File:** `oh-my-opencode-slim.json`
+```json
+{
+  "agents": {
+    "orchestrator": {
+      "model": "openai/gpt-5.2-codex",
+      "variant": "high"
+    },
+    "explore": {
+      "model": "opencode/glm-4.7",
+      "variant": "low"
+    }
+  },
+  "disabled_agents": ["multimodal-looker", "code-simplicity-reviewer"]
+}
+```
+
+#### Agent Settings Reference
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `agents.<name>.model` | string | *Varies* | Override the LLM for a specific agent |
+| `agents.<name>.variant` | string | `"medium"` | Reasoning level (`low`, `medium`, `high`) |
+| `disabled_agents` | array | `[]` | List of agents to completely deactivate |
+
+---
+
+### Tmux Setup
+
+Watch your agents work in real-time by enabling the Tmux integration. This requires the [OpenCode Server](#opencode-server) to be active.
+
+**File:** `oh-my-opencode-slim.json`
+```json
+{
+  "tmux": {
+    "enabled": true,
+    "layout": "main-vertical",
+    "main_pane_size": 60
+  }
+}
+```
 
-You can customize the behavior of the plugin via JSON configuration files.
+#### Tmux Settings Reference
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `enabled` | boolean | `false` | Enable/disable tmux integration |
+| `layout` | string | `"main-vertical"` | Layout preset (see below) |
+| `main_pane_size` | number | `60` | Size of main session pane as % (20-80) |
 
-### Configuration Files
+**Available Layouts:**
+- `main-vertical`: Main session left, agents stacked right.
+- `main-horizontal`: Main session top, agents stacked below.
+- `tiled`: Equal-sized grid.
+- `even-horizontal` / `even-vertical`: Evenly distributed panes.
 
-The plugin looks for configuration in two places (and merges them):
+---
 
-1. **User Global**: `~/.config/opencode/oh-my-opencode-slim.json` (or OS equivalent)
-2. **Project Local**: `./.opencode/oh-my-opencode-slim.json`
+### MCP Management
 
-| Platform | User Config Path |
-| :--- | :--- |
-| **Windows** | `~/.config/opencode/oh-my-opencode-slim.json` or `%APPDATA%\opencode\oh-my-opencode-slim.json` |
-| **macOS/Linux** | `~/.config/opencode/oh-my-opencode-slim.json` |
+The Pantheon comes equipped with built-in Model Context Protocol (MCP) servers.
 
-### Disabling Agents
+| MCP | Purpose | URL |
+|-----|---------|-----|
+| `websearch` | Real-time web search via Exa AI | `https://mcp.exa.ai/mcp` |
+| `context7` | Official library documentation | `https://mcp.context7.com/mcp` |
+| `grep_app` | GitHub code search via grep.app | `https://mcp.grep.app` |
 
-You can disable specific agents using the `disabled_agents` array:
+#### Disabling MCPs
+If you wish to silence an MCP server, add it to the `disabled_mcps` array in your config:
 
+**File:** `oh-my-opencode-slim.json`
 ```json
 {
-  "disabled_agents": ["multimodal-looker", "code-simplicity-reviewer"]
+  "disabled_mcps": ["websearch", "grep_app"]
 }
 ```
 
 ---
 
-## Uninstallation
+## 🗑️ Uninstallation
 
 1. **Remove the plugin from your OpenCode config**:
-
    Edit `~/.config/opencode/opencode.json` and remove `"oh-my-opencode-slim"` from the `plugin` array.
 
 2. **Remove configuration files (optional)**:

package/dist/agents/coder.d.ts

@@ -0,0 +1,2 @@
+import type { AgentDefinition } from "./orchestrator";
+export declare function createCoderAgent(model: string): AgentDefinition;

package/dist/agents/index.d.ts

@@ -1,48 +1,8 @@
 import type { AgentConfig as SDKAgentConfig } from "@opencode-ai/sdk";
 import { type AgentName, type PluginConfig } from "../config";
 import { type AgentDefinition } from "./orchestrator";
-import { createOracleAgent } from "./oracle";
-import { createLibrarianAgent } from "./librarian";
-import { createExploreAgent } from "./explore";
-import { createFrontendAgent } from "./frontend";
-import { createDocumentWriterAgent } from "./document-writer";
-import { createMultimodalAgent } from "./multimodal";
-import { createSimplicityReviewerAgent } from "./simplicity-reviewer";
 export type { AgentDefinition } from "./orchestrator";
 type SubagentName = Exclude<AgentName, "orchestrator">;
-/** Short descriptions for each subagent (used in tool descriptions) */
-export declare const SUBAGENT_INFO: {
-    readonly explore: {
-        readonly factory: typeof createExploreAgent;
-        readonly shortDesc: "codebase grep";
-    };
-    readonly librarian: {
-        readonly factory: typeof createLibrarianAgent;
-        readonly shortDesc: "docs/GitHub";
-    };
-    readonly oracle: {
-        readonly factory: typeof createOracleAgent;
-        readonly shortDesc: "strategy";
-    };
-    readonly "frontend-ui-ux-engineer": {
-        readonly factory: typeof createFrontendAgent;
-        readonly shortDesc: "UI/UX";
-    };
-    readonly "document-writer": {
-        readonly factory: typeof createDocumentWriterAgent;
-        readonly shortDesc: "docs";
-    };
-    readonly "multimodal-looker": {
-        readonly factory: typeof createMultimodalAgent;
-        readonly shortDesc: "image/visual analysis";
-    };
-    readonly "code-simplicity-reviewer": {
-        readonly factory: typeof createSimplicityReviewerAgent;
-        readonly shortDesc: "code review";
-    };
-};
-/** Generate agent list string for tool descriptions */
-export declare function getAgentListDescription(): string;
 /** Get list of agent names */
 export declare function getAgentNames(): SubagentName[];
 export declare function createAgents(config?: PluginConfig): AgentDefinition[];

package/dist/agents/orchestrator.d.ts

@@ -1,7 +1,7 @@
 import type { AgentConfig } from "@opencode-ai/sdk";
 export interface AgentDefinition {
     name: string;
-    description: string;
+    description?: string;
     config: AgentConfig;
 }
-export declare function createOrchestratorAgent(model: string, subAgents: AgentDefinition[]): AgentDefinition;
+export declare function createOrchestratorAgent(model: string): AgentDefinition;

package/dist/agents/scribe.d.ts

@@ -0,0 +1,2 @@
+import type { AgentDefinition } from "./orchestrator";
+export declare function createScribeAgent(model: string): AgentDefinition;

package/dist/cli/config-manager.d.ts

@@ -12,4 +12,8 @@ export declare function addProviderConfig(installConfig: InstallConfig): ConfigM
 export declare function addServerConfig(installConfig: InstallConfig): ConfigMergeResult;
 export declare function generateLiteConfig(installConfig: InstallConfig): Record<string, unknown>;
 export declare function writeLiteConfig(installConfig: InstallConfig): ConfigMergeResult;
+/**
+ * Disable OpenCode's default subagents since the plugin provides its own
+ */
+export declare function disableDefaultAgents(): ConfigMergeResult;
 export declare function detectCurrentConfig(): DetectedConfig;

package/dist/cli/index.js

@@ -51,18 +51,6 @@ async function isOpenCodeInstalled() {
     return false;
   }
 }
-async function isTmuxInstalled() {
-  try {
-    const proc = Bun.spawn(["tmux", "-V"], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    await proc.exited;
-    return proc.exitCode === 0;
-  } catch {
-    return false;
-  }
-}
 async function getOpenCodeVersion() {
   try {
     const proc = Bun.spawn(["opencode", "--version"], {
@@ -193,29 +181,6 @@ function addProviderConfig(installConfig) {
     };
   }
 }
-function addServerConfig(installConfig) {
-  const configPath = getConfigJson();
-  try {
-    ensureConfigDir();
-    let config = parseConfig(configPath) ?? {};
-    if (installConfig.hasTmux) {
-      const server = config.server ?? {};
-      if (server.port === undefined) {
-        server.port = 4096;
-      }
-      config.server = server;
-    }
-    writeFileSync(configPath, JSON.stringify(config, null, 2) + `
-`);
-    return { success: true, configPath };
-  } catch (err) {
-    return {
-      success: false,
-      configPath,
-      error: `Failed to add server config: ${err}`
-    };
-  }
-}
 var MODEL_MAPPINGS = {
   antigravity: {
     orchestrator: "google/claude-opus-4-5-thinking",
@@ -290,6 +255,26 @@ function writeLiteConfig(installConfig) {
     };
   }
 }
+function disableDefaultAgents() {
+  const configPath = getConfigJson();
+  try {
+    ensureConfigDir();
+    let config = parseConfig(configPath) ?? {};
+    const agent = config.agent ?? {};
+    agent.explore = { disable: true };
+    agent.general = { disable: true };
+    config.agent = agent;
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + `
+`);
+    return { success: true, configPath };
+  } catch (err) {
+    return {
+      success: false,
+      configPath,
+      error: `Failed to disable default agents: ${err}`
+    };
+  }
+}
 function detectCurrentConfig() {
   const result = {
     isInstalled: false,
@@ -424,8 +409,7 @@ async function askYesNo(rl, prompt, defaultValue = "no") {
 }
 async function runInteractiveMode(detected) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  const tmuxInstalled = await isTmuxInstalled();
-  const totalQuestions = tmuxInstalled ? 4 : 3;
+  const totalQuestions = 3;
   try {
     console.log(`${BOLD}Question 1/${totalQuestions}:${RESET}`);
     printInfo("The Pantheon is tuned for Antigravity's model routing. Other models work, but results may vary.");
@@ -437,19 +421,11 @@ async function runInteractiveMode(detected) {
     console.log(`${BOLD}Question 3/${totalQuestions}:${RESET}`);
     const cerebras = await askYesNo(rl, "Do you have access to Cerebras API?", detected.hasCerebras ? "yes" : "no");
     console.log();
-    let tmux = "no";
-    if (tmuxInstalled) {
-      console.log(`${BOLD}Question 4/4:${RESET}`);
-      printInfo(`${BOLD}Tmux detected!${RESET} We can enable tmux integration for you.`);
-      printInfo("This will spawn new panes for sub-agents, letting you watch them work in real-time.");
-      tmux = await askYesNo(rl, "Enable tmux integration?", detected.hasTmux ? "yes" : "no");
-      console.log();
-    }
     return {
       hasAntigravity: antigravity === "yes",
       hasOpenAI: openai === "yes",
       hasCerebras: cerebras === "yes",
-      hasTmux: tmux === "yes"
+      hasTmux: false
     };
   } finally {
     rl.close();
@@ -459,11 +435,9 @@ async function runInstall(config) {
   const detected = detectCurrentConfig();
   const isUpdate = detected.isInstalled;
   printHeader(isUpdate);
-  let totalSteps = 3;
+  let totalSteps = 4;
   if (config.hasAntigravity)
     totalSteps += 2;
-  if (config.hasTmux)
-    totalSteps += 1;
   let step = 1;
   printStep(step++, totalSteps, "Checking OpenCode installation...");
   const { ok } = await checkOpenCodeInstalled();
@@ -473,6 +447,10 @@ async function runInstall(config) {
   const pluginResult = await addPluginToOpenCodeConfig();
   if (!handleStepResult(pluginResult, "Plugin added"))
     return 1;
+  printStep(step++, totalSteps, "Disabling OpenCode default agents...");
+  const agentResult = disableDefaultAgents();
+  if (!handleStepResult(agentResult, "Default agents disabled"))
+    return 1;
   if (config.hasAntigravity) {
     printStep(step++, totalSteps, "Adding auth plugins...");
     const authResult = await addAuthPlugins(config);
@@ -483,12 +461,6 @@ async function runInstall(config) {
     if (!handleStepResult(providerResult, "Providers configured"))
       return 1;
   }
-  if (config.hasTmux) {
-    printStep(step++, totalSteps, "Configuring OpenCode HTTP server for tmux...");
-    const serverResult = addServerConfig(config);
-    if (!handleStepResult(serverResult, "Server configured"))
-      return 1;
-  }
   printStep(step++, totalSteps, "Writing oh-my-opencode-slim configuration...");
   const liteResult = writeLiteConfig(config);
   if (!handleStepResult(liteResult, "Config written"))
@@ -509,14 +481,8 @@ async function runInstall(config) {
   console.log(`  ${nextStep++}. Authenticate with your providers:`);
   console.log(`     ${BLUE}$ opencode auth login${RESET}`);
   console.log();
-  if (config.hasTmux) {
-    console.log(`  ${nextStep++}. Run OpenCode inside tmux:`);
-    console.log(`     ${BLUE}$ tmux${RESET}`);
-    console.log(`     ${BLUE}$ opencode${RESET}`);
-  } else {
-    console.log(`  ${nextStep++}. Start OpenCode:`);
-    console.log(`     ${BLUE}$ opencode${RESET}`);
-  }
+  console.log(`  ${nextStep++}. Start OpenCode:`);
+  console.log(`     ${BLUE}$ opencode${RESET}`);
   console.log();
   return 0;
 }

package/dist/config/schema.d.ts

@@ -4,6 +4,7 @@ export declare const AgentOverrideConfigSchema: z.ZodObject<{
     temperature: z.ZodOptional<z.ZodNumber>;
     prompt: z.ZodOptional<z.ZodString>;
     prompt_append: z.ZodOptional<z.ZodString>;
+    variant: z.ZodCatch<z.ZodOptional<z.ZodString>>;
     disable: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export declare const TmuxLayoutSchema: z.ZodEnum<{
@@ -39,6 +40,7 @@ export declare const PluginConfigSchema: z.ZodObject<{
         temperature: z.ZodOptional<z.ZodNumber>;
         prompt: z.ZodOptional<z.ZodString>;
         prompt_append: z.ZodOptional<z.ZodString>;
+        variant: z.ZodCatch<z.ZodOptional<z.ZodString>>;
         disable: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>>;
     disabled_agents: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/dist/features/background-manager.d.ts

@@ -1,5 +1,6 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 import type { TmuxConfig } from "../config/schema";
+import type { PluginConfig } from "../config";
 export interface BackgroundTask {
     id: string;
     sessionId: string;
@@ -24,7 +25,8 @@ export declare class BackgroundTaskManager {
     private directory;
     private pollInterval?;
     private tmuxEnabled;
-    constructor(ctx: PluginInput, tmuxConfig?: TmuxConfig);
+    private config?;
+    constructor(ctx: PluginInput, tmuxConfig?: TmuxConfig, config?: PluginConfig);
     launch(opts: LaunchOptions): Promise<BackgroundTask>;
     getResult(taskId: string, block?: boolean, timeout?: number): Promise<BackgroundTask | null>;
     cancel(taskId?: string): number;

package/dist/index.js

@@ -20484,6 +20484,7 @@ var AgentOverrideConfigSchema = exports_external.object({
   temperature: exports_external.number().min(0).max(2).optional(),
   prompt: exports_external.string().optional(),
   prompt_append: exports_external.string().optional(),
+  variant: exports_external.string().optional().catch(undefined),
   disable: exports_external.boolean().optional()
 });
 var TmuxLayoutSchema = exports_external.enum([
@@ -20585,73 +20586,172 @@ function loadPluginConfig(directory) {
   return config2;
 }
 // src/agents/orchestrator.ts
-function createOrchestratorAgent(model, subAgents) {
-  const agentTable = subAgents.map((a) => `| @${a.name} | ${a.description} |`).join(`
-`);
-  const prompt = ORCHESTRATOR_PROMPT_TEMPLATE.replace("{{AGENT_TABLE}}", agentTable);
+function createOrchestratorAgent(model) {
   return {
     name: "orchestrator",
-    description: "AI coding orchestrator with access to specialized subagents",
     config: {
       model,
       temperature: 0.1,
-      system: prompt
+      prompt: ORCHESTRATOR_PROMPT
     }
   };
 }
-var ORCHESTRATOR_PROMPT_TEMPLATE = `<Role>
-You are an AI coding orchestrator with access to specialized subagents.
+var ORCHESTRATOR_PROMPT = `<Role>
+You are an AI coding orchestrator. You DO NOT implement - you DELEGATE.
+
+**Your Identity:**
+- You are a CONDUCTOR, not a musician
+- You are a MANAGER, not a worker  
+- You are a ROUTER, not a processor
+
+**Core Rule:** If a specialist agent can do the work, YOU MUST delegate to them.
 
-**Core Competencies**:
-- Parse implicit requirements from explicit requests
-- Delegate specialized work to the right subagents
-- Sensible parallel execution
+**Why Delegation Matters:**
+- @frontend-ui-ux-engineer \u2192 10x better designs than you \u2192 improves quality
+- @librarian \u2192 finds docs you'd miss \u2192 improves speed and quality
+- @explore \u2192 searches faster than you \u2192  improves speed
+- @oracle \u2192 catches architectural issues you'd overlook \u2192 improves quality
+- @document-writer \u2192 writes cleaner docs for less cost \u2192 reduceses cost
+- @code-simplicity-reviewer \u2192 spots complexity you're blind to \u2192 improves quality
+- @multimodal-looker \u2192 understands images you can't parse \u2192 improves speed and quality
 
+**Your value is in orchestration, not implementation.**
 </Role>
 
-<Subagents>
-| Agent | Purpose / When to Use |
-|-------|-----------------------|
-{{AGENT_TABLE}}
-</Subagents>
+<Agents>
+## Research Agents (Background-friendly)
 
-<Delegation>
-Delegate when specialists are available.
+@explore - Fast codebase search and pattern matching
+  Triggers: "find", "where is", "search for", "which file", "locate"
+  Example: background_task(agent="explore", prompt="Find all authentication implementations")
 
-## Background Tasks
-Use background_task for parallel work when needed:
-\`\`\`
-background_task(agent="explore", prompt="Find all auth implementations")
-background_task(agent="librarian", prompt="How does library X handle Y")
-\`\`\`
+@librarian - External documentation and library research  
+  Triggers: "how does X library work", "docs for", "API reference", "best practice for"
+  Example: background_task(agent="librarian", prompt="How does React Query handle cache invalidation")
 
-## When to Delegate
-- Use the subagent most relevant to the task description.
-- Use background tasks for research or search while you continue working.
+## Advisory Agents (Usually sync)
 
-## Skills
-- For browser-related tasks (verification, screenshots, scraping, testing), call the "omo_skill" tool with name "playwright" before taking action. Use relative filenames for screenshots (e.g., 'screenshot.png'); they are saved within subdirectories of '/tmp/playwright-mcp-output/'. Use the "omo_skill_mcp" tool to invoke browser actions with camelCase parameters: skillName, mcpName, toolName, and toolArgs.
-</Delegation>
+@oracle - Architecture, debugging, and strategic code review
+  Triggers: "should I", "why does", "review", "debug", "what's wrong", "tradeoffs"
+  Use when: Complex decisions, mysterious bugs, architectural uncertainty
+
+@code-simplicity-reviewer - Complexity analysis and YAGNI enforcement
+  Triggers: "too complex", "simplify", "review for complexity", after major refactors
+  Use when: After writing significant code, before finalizing PRs
+
+## Implementation Agents (Sync)
+
+@frontend-ui-ux-engineer - UI/UX design and implementation
+  Triggers: "styling", "responsive", "UI", "UX", "component design", "CSS", "animation"
+  Use when: Any visual/frontend work that needs design sense
+
+@document-writer - Technical documentation and knowledge capture
+  Triggers: "document", "README", "update docs", "explain in docs"
+  Use when: After features are implemented, before closing tasks
+
+@multimodal-looker - Image and visual content analysis
+  Triggers: User provides image, screenshot, diagram, mockup
+  Use when: Need to extract info from visual inputs
+</Agents>
 
 <Workflow>
-1. Understand the request fully
-2. If multi-step: create TODO list first
-3. For search: fire parallel explore agents
-4. Use LSP tools for refactoring (safer than text edits)
-5. Verify with lsp_diagnostics after changes
-6. Mark TODOs complete as you finish each
+## Phase 1: Understand
+Parse the request. Identify explicit and implicit requirements.
+
+## Phase 2: Delegation Gate (MANDATORY - DO NOT SKIP)
+
+STOP. Before ANY implementation, you MUST complete this checklist:
+
+\`\`\`
+DELEGATION CHECKLIST (complete before coding):
+[ ] UI/styling/design/visual/CSS/animation? \u2192 @frontend-ui-ux-engineer MUST handle
+[ ] Need codebase context? \u2192 @explore first  
+[ ] External library/API docs needed? \u2192 @librarian first
+[ ] Architecture decision or debugging? \u2192 @oracle first
+[ ] Image/screenshot/diagram provided? \u2192 @multimodal-looker first
+[ ] Documentation to write? \u2192 @document-writer handles
+\`\`\`
+
+**CRITICAL RULES:**
+1. If ANY checkbox applies \u2192 delegate BEFORE you write code
+2. Reading files for context \u2260 completing the task. Context gathering is Phase 1, not Phase 3.
+3. Your job is to DELEGATE task when specialize provide improved speed, quality or cost, not to DO it yourself this time.
+
+**Anti-patterns to avoid:**
+- Reading files \u2192 feeling productive \u2192 implementing yourself (WRONG)
+- Creating todos \u2192 feeling like you planned \u2192 skipping delegation (WRONG)
+- "I can handle this" \u2192 doing specialist work yourself (WRONG)
+
+## Phase 2.1: Task Planning
+1. If task has 2+ steps \u2192 Create todo list with delegations noted
+2. Mark current task \`in_progress\` before starting
+3. Mark \`completed\` immediately when done
+
+## Phase 3: Execute
+1. Fire background research (explore, librarian) in parallel
+2. DELEGATE implementation to specialists based on Phase 2 checklist
+3. Only do work yourself if NO specialist applies
+4. Integrate results from specialists
+
+## Phase 4: Verify
+- Run lsp_diagnostics to check for errors
+- @code-simplicity-reviewer for complex changes
+- Update documentation if behavior changed
 </Workflow>
+
+### Clarification Protocol (when asking):
+
+\`\`\`
+I want to make sure I understand correctly.
+
+**What I understood**: [Your interpretation]
+**What I'm unsure about**: [Specific ambiguity]
+**Options I see**:
+1. [Option A] - [effort/implications]
+2. [Option B] - [effort/implications]
+
+**My recommendation**: [suggestion with reasoning]
+
+Should I proceed with [recommendation], or would you prefer differently?
+\`\`\`
+
+## Communication Style
+
+### Be Concise
+- Start work immediately. No acknowledgments ("I'm on it", "Let me...", "I'll start...") 
+- Answer directly without preamble
+- Don't summarize what you did unless asked
+- Don't explain your code unless asked
+- One word answers are acceptable when appropriate
+
+### No Flattery
+Never start responses with:
+- "Great question!"
+- "That's a really good idea!"
+- "Excellent choice!"
+- Any praise of the user's input
+
+### When User is Wrong
+If the user's approach seems problematic:
+- Don't blindly implement it
+- Don't lecture or be preachy
+- Concisely state your concern and alternative
+- Ask if they want to proceed anyway
+
+## Skills
+For browser tasks (verification, screenshots, scraping), call omo_skill with name "playwright" first.
+Use omo_skill_mcp to invoke browser actions. Screenshots save to '/tmp/playwright-mcp-output/'.
 `;
 
 // src/agents/oracle.ts
 function createOracleAgent(model) {
   return {
     name: "oracle",
-    description: "Architecture, debugging, and code review",
+    description: "Strategic technical advisor. Use for architecture decisions, complex debugging, code review, and engineering guidance.",
     config: {
       model,
       temperature: 0.1,
-      system: ORACLE_PROMPT
+      prompt: ORACLE_PROMPT
     }
   };
 }
@@ -20680,11 +20780,11 @@ var ORACLE_PROMPT = `You are Oracle - a strategic technical advisor.
 function createLibrarianAgent(model) {
   return {
     name: "librarian",
-    description: "External documentation and library research",
+    description: "External documentation and library research. Use for official docs lookup, GitHub examples, and understanding library internals.",
     config: {
       model,
       temperature: 0.1,
-      system: LIBRARIAN_PROMPT
+      prompt: LIBRARIAN_PROMPT
     }
   };
 }
@@ -20713,11 +20813,11 @@ var LIBRARIAN_PROMPT = `You are Librarian - a research specialist for codebases
 function createExploreAgent(model) {
   return {
     name: "explore",
-    description: "Fast codebase search and pattern matching",
+    description: "Fast codebase search and pattern matching. Use for finding files, locating code patterns, and answering 'where is X?' questions.",
     config: {
       model,
       temperature: 0.1,
-      system: EXPLORE_PROMPT
+      prompt: EXPLORE_PROMPT
     }
   };
 }
@@ -20764,11 +20864,11 @@ Concise answer to the question
 function createFrontendAgent(model) {
   return {
     name: "frontend-ui-ux-engineer",
-    description: "UI/UX implementation and visual changes",
+    description: "UI/UX design and implementation. Use for styling, responsive design, component architecture, CSS/Tailwind, and visual polish.",
     config: {
       model,
       temperature: 0.7,
-      system: FRONTEND_PROMPT
+      prompt: FRONTEND_PROMPT
     }
   };
 }
@@ -20799,11 +20899,11 @@ var FRONTEND_PROMPT = `You are a Frontend UI/UX Engineer - a designer turned dev
 function createDocumentWriterAgent(model) {
   return {
     name: "document-writer",
-    description: "Technical documentation and READMEs",
+    description: "Technical documentation writer. Use for README files, API docs, architecture docs, and user guides.",
     config: {
       model,
       temperature: 0.3,
-      system: DOCUMENT_WRITER_PROMPT
+      prompt: DOCUMENT_WRITER_PROMPT
     }
   };
 }
@@ -20832,11 +20932,11 @@ var DOCUMENT_WRITER_PROMPT = `You are a Technical Writer - crafting clear, compr
 function createMultimodalAgent(model) {
   return {
     name: "multimodal-looker",
-    description: "Image and UI analysis",
+    description: "Image and visual content analysis. Use for PDFs, screenshots, diagrams, mockups, and extracting info from visuals.",
     config: {
       model,
       temperature: 0.1,
-      system: MULTIMODAL_PROMPT
+      prompt: MULTIMODAL_PROMPT
     }
   };
 }
@@ -20865,11 +20965,11 @@ var MULTIMODAL_PROMPT = `You are a Multimodal Analyst - extracting information f
 function createSimplicityReviewerAgent(model) {
   return {
     name: "code-simplicity-reviewer",
-    description: "Ruthless code simplification and YAGNI principle enforcement",
+    description: "Code complexity analysis and YAGNI enforcement. Use after major refactors or before finalizing PRs to simplify code.",
     config: {
       model,
       temperature: 0.1,
-      system: SIMPLICITY_REVIEWER_PROMPT
+      prompt: SIMPLICITY_REVIEWER_PROMPT
     }
   };
 }
@@ -20960,32 +21060,33 @@ function applyOverrides(agent, override) {
   if (override.temperature !== undefined)
     agent.config.temperature = override.temperature;
   if (override.prompt)
-    agent.config.system = override.prompt;
+    agent.config.prompt = override.prompt;
   if (override.prompt_append) {
-    agent.config.system = `${agent.config.system}
+    agent.config.prompt = `${agent.config.prompt}
 
 ${override.prompt_append}`;
   }
 }
-var SUBAGENT_INFO = {
-  explore: { factory: createExploreAgent, shortDesc: "codebase grep" },
-  librarian: { factory: createLibrarianAgent, shortDesc: "docs/GitHub" },
-  oracle: { factory: createOracleAgent, shortDesc: "strategy" },
-  "frontend-ui-ux-engineer": { factory: createFrontendAgent, shortDesc: "UI/UX" },
-  "document-writer": { factory: createDocumentWriterAgent, shortDesc: "docs" },
-  "multimodal-looker": { factory: createMultimodalAgent, shortDesc: "image/visual analysis" },
-  "code-simplicity-reviewer": { factory: createSimplicityReviewerAgent, shortDesc: "code review" }
-};
-function getAgentListDescription() {
-  return Object.entries(SUBAGENT_INFO).map(([name, { shortDesc }]) => `${name} (${shortDesc})`).join(", ");
+function applyDefaultPermissions(agent) {
+  const existing = agent.config.permission ?? {};
+  agent.config.permission = { ...existing, question: "allow" };
 }
+var SUBAGENT_FACTORIES = {
+  explore: createExploreAgent,
+  librarian: createLibrarianAgent,
+  oracle: createOracleAgent,
+  "frontend-ui-ux-engineer": createFrontendAgent,
+  "document-writer": createDocumentWriterAgent,
+  "multimodal-looker": createMultimodalAgent,
+  "code-simplicity-reviewer": createSimplicityReviewerAgent
+};
 function getAgentNames() {
-  return Object.keys(SUBAGENT_INFO);
+  return Object.keys(SUBAGENT_FACTORIES);
 }
 function createAgents(config2) {
   const disabledAgents = new Set(config2?.disabled_agents ?? []);
   const agentOverrides = config2?.agents ?? {};
-  const protoSubAgents = Object.entries(SUBAGENT_INFO).map(([name, { factory }]) => factory(DEFAULT_MODELS[name]));
+  const protoSubAgents = Object.entries(SUBAGENT_FACTORIES).map(([name, factory]) => factory(DEFAULT_MODELS[name]));
   const allSubAgents = protoSubAgents.filter((a) => !disabledAgents.has(a.name)).map((agent) => {
     const override = agentOverrides[agent.name];
     if (override) {
@@ -20994,7 +21095,8 @@ function createAgents(config2) {
     return agent;
   });
   const orchestratorModel = agentOverrides["orchestrator"]?.model ?? DEFAULT_MODELS["orchestrator"];
-  const orchestrator = createOrchestratorAgent(orchestratorModel, allSubAgents);
+  const orchestrator = createOrchestratorAgent(orchestratorModel);
+  applyDefaultPermissions(orchestrator);
   const oOverride = agentOverrides["orchestrator"];
   if (oOverride) {
     applyOverrides(orchestrator, oOverride);
@@ -21003,158 +21105,7 @@ function createAgents(config2) {
 }
 function getAgentConfigs(config2) {
   const agents = createAgents(config2);
-  return Object.fromEntries(agents.map((a) => [a.name, a.config]));
-}
-
-// src/features/background-manager.ts
-function generateTaskId() {
-  return `bg_${Math.random().toString(36).substring(2, 10)}`;
-}
-
-class BackgroundTaskManager {
-  tasks = new Map;
-  client;
-  directory;
-  pollInterval;
-  tmuxEnabled;
-  constructor(ctx, tmuxConfig) {
-    this.client = ctx.client;
-    this.directory = ctx.directory;
-    this.tmuxEnabled = tmuxConfig?.enabled ?? false;
-  }
-  async launch(opts) {
-    const session = await this.client.session.create({
-      body: {
-        parentID: opts.parentSessionId,
-        title: `Background: ${opts.description}`
-      },
-      query: { directory: this.directory }
-    });
-    if (!session.data?.id) {
-      throw new Error("Failed to create background session");
-    }
-    const task = {
-      id: generateTaskId(),
-      sessionId: session.data.id,
-      description: opts.description,
-      agent: opts.agent,
-      status: "running",
-      startedAt: new Date
-    };
-    this.tasks.set(task.id, task);
-    this.startPolling();
-    if (this.tmuxEnabled) {
-      await new Promise((r) => setTimeout(r, 500));
-    }
-    const promptQuery = {
-      directory: this.directory
-    };
-    if (opts.model) {
-      promptQuery.model = opts.model;
-    }
-    await this.client.session.prompt({
-      path: { id: session.data.id },
-      body: {
-        agent: opts.agent,
-        tools: { background_task: false, task: false },
-        parts: [{ type: "text", text: opts.prompt }]
-      },
-      query: promptQuery
-    });
-    return task;
-  }
-  async getResult(taskId, block = false, timeout = 120000) {
-    const task = this.tasks.get(taskId);
-    if (!task)
-      return null;
-    if (!block || task.status === "completed" || task.status === "failed") {
-      return task;
-    }
-    const deadline = Date.now() + timeout;
-    while (Date.now() < deadline) {
-      await this.pollTask(task);
-      const status = task.status;
-      if (status === "completed" || status === "failed") {
-        return task;
-      }
-      await new Promise((r) => setTimeout(r, POLL_INTERVAL_SLOW_MS));
-    }
-    return task;
-  }
-  cancel(taskId) {
-    if (taskId) {
-      const task = this.tasks.get(taskId);
-      if (task && task.status === "running") {
-        task.status = "failed";
-        task.error = "Cancelled by user";
-        task.completedAt = new Date;
-        return 1;
-      }
-      return 0;
-    }
-    let count = 0;
-    for (const task of this.tasks.values()) {
-      if (task.status === "running") {
-        task.status = "failed";
-        task.error = "Cancelled by user";
-        task.completedAt = new Date;
-        count++;
-      }
-    }
-    return count;
-  }
-  startPolling() {
-    if (this.pollInterval)
-      return;
-    this.pollInterval = setInterval(() => this.pollAllTasks(), POLL_INTERVAL_BACKGROUND_MS);
-  }
-  async pollAllTasks() {
-    const runningTasks = [...this.tasks.values()].filter((t) => t.status === "running");
-    if (runningTasks.length === 0 && this.pollInterval) {
-      clearInterval(this.pollInterval);
-      this.pollInterval = undefined;
-      return;
-    }
-    for (const task of runningTasks) {
-      await this.pollTask(task);
-    }
-  }
-  async pollTask(task) {
-    try {
-      const statusResult = await this.client.session.status();
-      const allStatuses = statusResult.data ?? {};
-      const sessionStatus = allStatuses[task.sessionId];
-      if (sessionStatus && sessionStatus.type !== "idle") {
-        return;
-      }
-      const messagesResult = await this.client.session.messages({ path: { id: task.sessionId } });
-      const messages = messagesResult.data ?? messagesResult;
-      const assistantMessages = messages.filter((m) => m.info?.role === "assistant");
-      if (assistantMessages.length === 0) {
-        return;
-      }
-      const extractedContent = [];
-      for (const message of assistantMessages) {
-        for (const part of message.parts ?? []) {
-          if ((part.type === "text" || part.type === "reasoning") && part.text) {
-            extractedContent.push(part.text);
-          }
-        }
-      }
-      const responseText = extractedContent.filter((t) => t.length > 0).join(`
-
-`);
-      if (responseText) {
-        task.result = responseText;
-        task.status = "completed";
-        task.completedAt = new Date;
-      }
-    } catch (error48) {
-      task.status = "failed";
-      task.error = error48 instanceof Error ? error48.message : String(error48);
-      task.completedAt = new Date;
-    }
-  }
+  return Object.fromEntries(agents.map((a) => [a.name, { ...a.config, description: a.description }]));
 }
 // src/utils/tmux.ts
 var {spawn } = globalThis.Bun;
@@ -21375,7 +21326,193 @@ function startTmuxCheck() {
     getTmuxPath().catch(() => {});
   }
 }
+// src/utils/agent-variant.ts
+function normalizeAgentName(agentName) {
+  const trimmed = agentName.trim();
+  return trimmed.startsWith("@") ? trimmed.slice(1) : trimmed;
+}
+function resolveAgentVariant(config2, agentName) {
+  const normalized = normalizeAgentName(agentName);
+  const rawVariant = config2?.agents?.[normalized]?.variant;
+  if (typeof rawVariant !== "string") {
+    log(`[variant] no variant configured for agent "${normalized}"`);
+    return;
+  }
+  const trimmed = rawVariant.trim();
+  if (trimmed.length === 0) {
+    log(`[variant] empty variant for agent "${normalized}" (ignored)`);
+    return;
+  }
+  log(`[variant] resolved variant="${trimmed}" for agent "${normalized}"`);
+  return trimmed;
+}
+function applyAgentVariant(variant, body) {
+  if (!variant) {
+    log("[variant] no variant to apply (skipped)");
+    return body;
+  }
+  if (body.variant) {
+    log(`[variant] body already has variant="${body.variant}" (not overriding)`);
+    return body;
+  }
+  log(`[variant] applied variant="${variant}" to prompt body`);
+  return { ...body, variant };
+}
+// src/features/background-manager.ts
+function generateTaskId() {
+  return `bg_${Math.random().toString(36).substring(2, 10)}`;
+}
 
+class BackgroundTaskManager {
+  tasks = new Map;
+  client;
+  directory;
+  pollInterval;
+  tmuxEnabled;
+  config;
+  constructor(ctx, tmuxConfig, config2) {
+    this.client = ctx.client;
+    this.directory = ctx.directory;
+    this.tmuxEnabled = tmuxConfig?.enabled ?? false;
+    this.config = config2;
+  }
+  async launch(opts) {
+    const session = await this.client.session.create({
+      body: {
+        parentID: opts.parentSessionId,
+        title: `Background: ${opts.description}`
+      },
+      query: { directory: this.directory }
+    });
+    if (!session.data?.id) {
+      throw new Error("Failed to create background session");
+    }
+    const task = {
+      id: generateTaskId(),
+      sessionId: session.data.id,
+      description: opts.description,
+      agent: opts.agent,
+      status: "running",
+      startedAt: new Date
+    };
+    this.tasks.set(task.id, task);
+    this.startPolling();
+    if (this.tmuxEnabled) {
+      await new Promise((r) => setTimeout(r, 500));
+    }
+    const promptQuery = {
+      directory: this.directory
+    };
+    if (opts.model) {
+      promptQuery.model = opts.model;
+    }
+    log(`[background-manager] launching task for agent="${opts.agent}"`, { description: opts.description });
+    const resolvedVariant = resolveAgentVariant(this.config, opts.agent);
+    const promptBody = applyAgentVariant(resolvedVariant, {
+      agent: opts.agent,
+      tools: { background_task: false, task: false },
+      parts: [{ type: "text", text: opts.prompt }]
+    });
+    await this.client.session.prompt({
+      path: { id: session.data.id },
+      body: promptBody,
+      query: promptQuery
+    });
+    return task;
+  }
+  async getResult(taskId, block = false, timeout = 120000) {
+    const task = this.tasks.get(taskId);
+    if (!task)
+      return null;
+    if (!block || task.status === "completed" || task.status === "failed") {
+      return task;
+    }
+    const deadline = Date.now() + timeout;
+    while (Date.now() < deadline) {
+      await this.pollTask(task);
+      const status = task.status;
+      if (status === "completed" || status === "failed") {
+        return task;
+      }
+      await new Promise((r) => setTimeout(r, POLL_INTERVAL_SLOW_MS));
+    }
+    return task;
+  }
+  cancel(taskId) {
+    if (taskId) {
+      const task = this.tasks.get(taskId);
+      if (task && task.status === "running") {
+        task.status = "failed";
+        task.error = "Cancelled by user";
+        task.completedAt = new Date;
+        return 1;
+      }
+      return 0;
+    }
+    let count = 0;
+    for (const task of this.tasks.values()) {
+      if (task.status === "running") {
+        task.status = "failed";
+        task.error = "Cancelled by user";
+        task.completedAt = new Date;
+        count++;
+      }
+    }
+    return count;
+  }
+  startPolling() {
+    if (this.pollInterval)
+      return;
+    this.pollInterval = setInterval(() => this.pollAllTasks(), POLL_INTERVAL_BACKGROUND_MS);
+  }
+  async pollAllTasks() {
+    const runningTasks = [...this.tasks.values()].filter((t) => t.status === "running");
+    if (runningTasks.length === 0 && this.pollInterval) {
+      clearInterval(this.pollInterval);
+      this.pollInterval = undefined;
+      return;
+    }
+    for (const task of runningTasks) {
+      await this.pollTask(task);
+    }
+  }
+  async pollTask(task) {
+    try {
+      const statusResult = await this.client.session.status();
+      const allStatuses = statusResult.data ?? {};
+      const sessionStatus = allStatuses[task.sessionId];
+      if (sessionStatus && sessionStatus.type !== "idle") {
+        return;
+      }
+      const messagesResult = await this.client.session.messages({ path: { id: task.sessionId } });
+      const messages = messagesResult.data ?? messagesResult;
+      const assistantMessages = messages.filter((m) => m.info?.role === "assistant");
+      if (assistantMessages.length === 0) {
+        return;
+      }
+      const extractedContent = [];
+      for (const message of assistantMessages) {
+        for (const part of message.parts ?? []) {
+          if ((part.type === "text" || part.type === "reasoning") && part.text) {
+            extractedContent.push(part.text);
+          }
+        }
+      }
+      const responseText = extractedContent.filter((t) => t.length > 0).join(`
+
+`);
+      if (responseText) {
+        task.result = responseText;
+        task.status = "completed";
+        task.completedAt = new Date;
+      }
+    } catch (error48) {
+      task.status = "failed";
+      task.error = error48 instanceof Error ? error48.message : String(error48);
+      task.completedAt = new Date;
+    }
+  }
+}
 // src/features/tmux-session-manager.ts
 var POLL_INTERVAL_MS2 = 2000;
 var SESSION_TIMEOUT_MS = 10 * 60 * 1000;
@@ -33826,13 +33963,12 @@ function tool(input) {
 tool.schema = exports_external2;
 // src/tools/background.ts
 var z2 = tool.schema;
-function createBackgroundTools(ctx, manager, tmuxConfig) {
-  const agentList = getAgentListDescription();
+function createBackgroundTools(ctx, manager, tmuxConfig, pluginConfig) {
   const agentNames = getAgentNames().join(", ");
   const background_task = tool({
     description: `Run agent task. Use sync=true to wait for result, sync=false (default) to run in background.
 
-Agents: ${agentList}.
+Agents: ${agentNames}.
 
 Async mode returns task_id immediately - use \`background_output\` to get results.
 Sync mode blocks until completion and returns the result directly.`,
@@ -33850,7 +33986,7 @@ Sync mode blocks until completion and returns the result directly.`,
       const description = String(args.description);
       const isSync = args.sync === true;
       if (isSync) {
-        return await executeSync(description, prompt, agent, tctx, ctx, tmuxConfig, args.session_id);
+        return await executeSync(description, prompt, agent, tctx, ctx, tmuxConfig, pluginConfig, args.session_id);
       }
       const task = await manager.launch({
         agent,
@@ -33921,7 +34057,7 @@ Duration: ${duration5}
   });
   return { background_task, background_output, background_cancel };
 }
-async function executeSync(description, prompt, agent, toolContext, ctx, tmuxConfig, existingSessionId) {
+async function executeSync(description, prompt, agent, toolContext, ctx, tmuxConfig, pluginConfig, existingSessionId) {
   let sessionID;
   if (existingSessionId) {
     const sessionResult = await ctx.client.session.get({ path: { id: existingSessionId } });
@@ -33947,14 +34083,18 @@ async function executeSync(description, prompt, agent, toolContext, ctx, tmuxCon
       await new Promise((r) => setTimeout(r, 500));
     }
   }
+  log(`[background-sync] launching sync task for agent="${agent}"`, { description });
+  const resolvedVariant = resolveAgentVariant(pluginConfig, agent);
+  const baseBody = {
+    agent,
+    tools: { background_task: false, task: false },
+    parts: [{ type: "text", text: prompt }]
+  };
+  const promptBody = applyAgentVariant(resolvedVariant, baseBody);
   try {
     await ctx.client.session.prompt({
       path: { id: sessionID },
-      body: {
-        agent,
-        tools: { background_task: false, task: false },
-        parts: [{ type: "text", text: prompt }]
-      }
+      body: promptBody
     });
   } catch (error92) {
     return `Error: Failed to send prompt: ${error92 instanceof Error ? error92.message : String(error92)}
@@ -40836,8 +40976,8 @@ var OhMyOpenCodeLite = async (ctx) => {
   if (tmuxConfig.enabled) {
     startTmuxCheck();
   }
-  const backgroundManager = new BackgroundTaskManager(ctx, tmuxConfig);
-  const backgroundTools = createBackgroundTools(ctx, backgroundManager, tmuxConfig);
+  const backgroundManager = new BackgroundTaskManager(ctx, tmuxConfig, config3);
+  const backgroundTools = createBackgroundTools(ctx, backgroundManager, tmuxConfig, config3);
   const mcps = createBuiltinMcps(config3.disabled_mcps);
   const skillMcpManager = SkillMcpManager.getInstance();
   const skillTools = createSkillTools(skillMcpManager);

package/dist/tools/background.d.ts

@@ -1,4 +1,5 @@
 import { type PluginInput, type ToolDefinition } from "@opencode-ai/plugin";
 import type { BackgroundTaskManager } from "../features";
 import type { TmuxConfig } from "../config/schema";
-export declare function createBackgroundTools(ctx: PluginInput, manager: BackgroundTaskManager, tmuxConfig?: TmuxConfig): Record<string, ToolDefinition>;
+import type { PluginConfig } from "../config";
+export declare function createBackgroundTools(ctx: PluginInput, manager: BackgroundTaskManager, tmuxConfig?: TmuxConfig, pluginConfig?: PluginConfig): Record<string, ToolDefinition>;

package/dist/utils/agent-variant.d.ts

@@ -0,0 +1,6 @@
+import type { PluginConfig } from "../config";
+export declare function normalizeAgentName(agentName: string): string;
+export declare function resolveAgentVariant(config: PluginConfig | undefined, agentName: string): string | undefined;
+export declare function applyAgentVariant<T extends {
+    variant?: string;
+}>(variant: string | undefined, body: T): T;

package/dist/utils/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./polling";
 export * from "./tmux";
+export * from "./agent-variant";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode-slim",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "description": "Lightweight agent orchestration plugin for OpenCode - a slimmed-down fork of oh-my-opencode",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",