oh-my-claudecode-opencode 0.6.11 → 0.7.0

package/bin/omco-setup.js

@@ -87,6 +87,16 @@ async function main() {
   };
   writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + `
 `);
+  try {
+    const written = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+    if (written.model_mapping?.tierDefaults) {
+      console.log(`
+✅ Config verification passed.`);
+    }
+  } catch {
+    console.error(`
+⚠️ Warning: Could not verify written config.`);
+  }
   console.log(`
 ✅ Configured tier mapping for ${provider}:
 `);

package/bin/omco-setup.ts

@@ -105,6 +105,16 @@ async function main() {
   // Write config
   writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n");
 
+  // Verify config can be read back
+  try {
+    const written = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+    if (written.model_mapping?.tierDefaults) {
+      console.log(`\n✅ Config verification passed.`);
+    }
+  } catch {
+    console.error(`\n⚠️ Warning: Could not verify written config.`);
+  }
+
   console.log(`\n✅ Configured tier mapping for ${provider}:\n`);
   console.log(`   haiku  → ${tiers.haiku}`);
   console.log(`   sonnet → ${tiers.sonnet}`);

package/dist/categories/constants.d.ts

@@ -0,0 +1,49 @@
+import type { CategoryConfig } from "./types";
+/**
+ * Prompt append for visual-engineering category.
+ * Encourages bold design choices and distinctive aesthetics.
+ */
+export declare const VISUAL_CATEGORY_PROMPT_APPEND = "<Category_Context>\nYou are working on VISUAL/UI tasks.\n\nDesign-first mindset:\n- Bold aesthetic choices over safe defaults\n- Unexpected layouts, asymmetry, grid-breaking elements\n- Distinctive typography (avoid: Arial, Inter, Roboto, Space Grotesk)\n- Cohesive color palettes with sharp accents\n- High-impact animations with staggered reveals\n- Atmosphere: gradient meshes, noise textures, layered transparencies\n\nAVOID: Generic fonts, purple gradients on white, predictable layouts, cookie-cutter patterns.\n</Category_Context>";
+/**
+ * Prompt append for ultrabrain category.
+ * Encourages strategic thinking and architectural clarity.
+ */
+export declare const ULTRABRAIN_CATEGORY_PROMPT_APPEND = "<Category_Context>\nYou are working on COMPLEX ARCHITECTURE / DEEP REASONING tasks.\n\nStrategic advisor mindset:\n- Bias toward simplicity: least complex solution that fulfills requirements\n- Leverage existing code/patterns over new components\n- Prioritize developer experience and maintainability\n- One clear recommendation with effort estimate (Quick/Short/Medium/Large)\n- Signal when advanced approach warranted\n\nResponse format:\n- Bottom line (2-3 sentences)\n- Action plan (numbered steps)\n- Risks and mitigations (if relevant)\n</Category_Context>";
+/**
+ * Prompt append for artistry category.
+ * Encourages radical creativity and unconventional approaches.
+ */
+export declare const ARTISTRY_CATEGORY_PROMPT_APPEND = "<Category_Context>\nYou are working on HIGHLY CREATIVE / ARTISTIC tasks.\n\nArtistic genius mindset:\n- Push far beyond conventional boundaries\n- Explore radical, unconventional directions\n- Surprise and delight: unexpected twists, novel combinations\n- Rich detail and vivid expression\n- Break patterns deliberately when it serves the creative vision\n\nApproach:\n- Generate diverse, bold options first\n- Embrace ambiguity and wild experimentation\n- Balance novelty with coherence\n- This is for tasks requiring exceptional creativity\n</Category_Context>";
+/**
+ * Prompt append for quick category.
+ * Optimized for fast, focused execution with less capable models.
+ */
+export declare const QUICK_CATEGORY_PROMPT_APPEND = "<Category_Context>\nYou are working on SMALL / QUICK tasks.\n\nEfficient execution mindset:\n- Fast, focused, minimal overhead\n- Get to the point immediately\n- No over-engineering\n- Simple solutions for simple problems\n\nApproach:\n- Minimal viable implementation\n- Skip unnecessary abstractions\n- Direct and concise\n</Category_Context>\n\n<Caller_Warning>\nTHIS CATEGORY USES A LESS CAPABLE MODEL (haiku tier).\n\nThe model executing this task has LIMITED reasoning capacity. Your prompt MUST be:\n\n**EXHAUSTIVELY EXPLICIT** - Leave NOTHING to interpretation:\n1. MUST DO: List every required action as atomic, numbered steps\n2. MUST NOT DO: Explicitly forbid likely mistakes and deviations\n3. EXPECTED OUTPUT: Describe exact success criteria with concrete examples\n\n**WHY THIS MATTERS:**\n- Less capable models WILL deviate without explicit guardrails\n- Vague instructions \u2192 unpredictable results\n- Implicit expectations \u2192 missed requirements\n\n**PROMPT STRUCTURE (MANDATORY):**\n```\nTASK: [One-sentence goal]\n\nMUST DO:\n1. [Specific action with exact details]\n2. [Another specific action]\n...\n\nMUST NOT DO:\n- [Forbidden action + why]\n- [Another forbidden action]\n...\n\nEXPECTED OUTPUT:\n- [Exact deliverable description]\n- [Success criteria / verification method]\n```\n\nIf your prompt lacks this structure, REWRITE IT before delegating.\n</Caller_Warning>";
+/**
+ * Prompt append for unspecified-low category.
+ * For moderate-effort tasks that don't fit specific categories.
+ */
+export declare const UNSPECIFIED_LOW_CATEGORY_PROMPT_APPEND = "<Category_Context>\nYou are working on tasks that don't fit specific categories but require moderate effort.\n\n<Selection_Gate>\nBEFORE selecting this category, VERIFY ALL conditions:\n1. Task does NOT fit: quick (trivial), visual-engineering (UI), ultrabrain (deep logic), artistry (creative), writing (docs)\n2. Task requires more than trivial effort but is NOT system-wide\n3. Scope is contained within a few files/modules\n\nIf task fits ANY other category, DO NOT select unspecified-low.\nThis is NOT a default choice - it's for genuinely unclassifiable moderate-effort work.\n</Selection_Gate>\n</Category_Context>\n\n<Caller_Warning>\nTHIS CATEGORY USES A MID-TIER MODEL (sonnet tier).\n\n**PROVIDE CLEAR STRUCTURE:**\n1. MUST DO: Enumerate required actions explicitly\n2. MUST NOT DO: State forbidden actions to prevent scope creep\n3. EXPECTED OUTPUT: Define concrete success criteria\n</Caller_Warning>";
+/**
+ * Prompt append for unspecified-high category.
+ * For high-effort tasks that don't fit specific categories.
+ */
+export declare const UNSPECIFIED_HIGH_CATEGORY_PROMPT_APPEND = "<Category_Context>\nYou are working on tasks that don't fit specific categories but require substantial effort.\n\n<Selection_Gate>\nBEFORE selecting this category, VERIFY ALL conditions:\n1. Task does NOT fit: quick (trivial), visual-engineering (UI), ultrabrain (deep logic), artistry (creative), writing (docs)\n2. Task requires substantial effort across multiple systems/modules\n3. Changes have broad impact or require careful coordination\n4. NOT just \"complex\" - must be genuinely unclassifiable AND high-effort\n\nIf task fits ANY other category, DO NOT select unspecified-high.\nIf task is unclassifiable but moderate-effort, use unspecified-low instead.\n</Selection_Gate>\n</Category_Context>";
+/**
+ * Prompt append for writing category.
+ * Optimized for documentation and prose tasks.
+ */
+export declare const WRITING_CATEGORY_PROMPT_APPEND = "<Category_Context>\nYou are working on WRITING / PROSE tasks.\n\nWordsmith mindset:\n- Clear, flowing prose\n- Appropriate tone and voice\n- Engaging and readable\n- Proper structure and organization\n\nApproach:\n- Understand the audience\n- Draft with care\n- Polish for clarity and impact\n- Documentation, READMEs, articles, technical writing\n</Category_Context>";
+/**
+ * Default category configurations.
+ * Uses abstract tier names (haiku/sonnet/opus) that will be resolved to actual provider/model by the model resolution service.
+ */
+export declare const DEFAULT_CATEGORIES: Record<string, CategoryConfig>;
+/**
+ * Map of category names to their prompt appends.
+ */
+export declare const CATEGORY_PROMPT_APPENDS: Record<string, string>;
+/**
+ * Map of category names to their human-readable descriptions.
+ */
+export declare const CATEGORY_DESCRIPTIONS: Record<string, string>;

package/dist/categories/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Categories module for OMCO.
+ *
+ * Categories provide semantic task classification that automatically maps to:
+ * - Model tier (haiku/sonnet/opus)
+ * - Temperature settings
+ * - Thinking budget (via variant)
+ * - Specialized prompt context
+ *
+ * This allows calling code to delegate tasks by semantic meaning rather than
+ * worrying about technical model selection details.
+ */
+export type { CategoryConfig, CategoriesConfig } from "./types";
+export { DEFAULT_CATEGORIES, CATEGORY_PROMPT_APPENDS, CATEGORY_DESCRIPTIONS, VISUAL_CATEGORY_PROMPT_APPEND, ULTRABRAIN_CATEGORY_PROMPT_APPEND, ARTISTRY_CATEGORY_PROMPT_APPEND, QUICK_CATEGORY_PROMPT_APPEND, UNSPECIFIED_LOW_CATEGORY_PROMPT_APPEND, UNSPECIFIED_HIGH_CATEGORY_PROMPT_APPEND, WRITING_CATEGORY_PROMPT_APPEND } from "./constants";
+export type { ResolvedCategory } from "./resolver";
+export { resolveCategoryConfig, getAvailableCategories } from "./resolver";

package/dist/categories/resolver.d.ts

@@ -0,0 +1,15 @@
+import type { CategoryConfig, CategoriesConfig } from "./types";
+export interface ResolvedCategory {
+    config: CategoryConfig;
+    promptAppend: string;
+    tier: string;
+}
+/**
+ * Resolve a category name to its configuration.
+ * Priority: user override > default category
+ */
+export declare function resolveCategoryConfig(categoryName: string, userCategories?: CategoriesConfig): ResolvedCategory | null;
+/**
+ * Get list of all available category names.
+ */
+export declare function getAvailableCategories(userCategories?: CategoriesConfig): string[];

package/dist/categories/types.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Configuration for a delegation category.
+ * Categories determine which model tier and behavior profile to use for delegated tasks.
+ */
+export interface CategoryConfig {
+    /** Abstract model tier name (haiku/sonnet/opus) - resolved by model resolution service */
+    model?: string;
+    /** Model variant for extended thinking budget */
+    variant?: "low" | "medium" | "high" | "max" | "xhigh";
+    /** Human-readable description of what this category is for */
+    description?: string;
+    /** Additional prompt context appended when using this category */
+    prompt_append?: string;
+    /** Flag indicating this agent configuration is experimental/unstable */
+    is_unstable_agent?: boolean;
+}
+/**
+ * Map of category names to their configurations.
+ */
+export type CategoriesConfig = Record<string, CategoryConfig>;

package/dist/config/index.d.ts

@@ -96,6 +96,32 @@ declare const AutopilotConfigSchema: z.ZodObject<{
         off: "off";
     }>>;
 }, z.core.$strip>;
+export declare const CategoryConfigSchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    variant: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        max: "max";
+        xhigh: "xhigh";
+    }>>;
+    description: z.ZodOptional<z.ZodString>;
+    prompt_append: z.ZodOptional<z.ZodString>;
+    is_unstable_agent: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const CategoriesConfigSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    variant: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        max: "max";
+        xhigh: "xhigh";
+    }>>;
+    description: z.ZodOptional<z.ZodString>;
+    prompt_append: z.ZodOptional<z.ZodString>;
+    is_unstable_agent: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>>;
 declare const UltraQAConfigSchema: z.ZodObject<{
     enabled: z.ZodOptional<z.ZodBoolean>;
     maxIterations: z.ZodOptional<z.ZodNumber>;
@@ -274,6 +300,19 @@ declare const OmoOmcsConfigSchema: z.ZodObject<{
         toastDuration: z.ZodOptional<z.ZodNumber>;
         trackMetrics: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
+    categories: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        variant: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            max: "max";
+            xhigh: "xhigh";
+        }>>;
+        description: z.ZodOptional<z.ZodString>;
+        prompt_append: z.ZodOptional<z.ZodString>;
+        is_unstable_agent: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
     omco_agent: z.ZodOptional<z.ZodObject<{
         disabled: z.ZodOptional<z.ZodBoolean>;
         planner_enabled: z.ZodOptional<z.ZodBoolean>;
@@ -296,6 +335,8 @@ export type McpServersConfig = z.infer<typeof McpServersConfigSchema>;
 export type PermissionsConfig = z.infer<typeof PermissionsConfigSchema>;
 export type MagicKeywordsConfig = z.infer<typeof MagicKeywordsConfigSchema>;
 export type RoutingConfig = z.infer<typeof RoutingConfigSchema>;
+export type CategoryConfig = z.infer<typeof CategoryConfigSchema>;
+export type CategoriesConfig = z.infer<typeof CategoriesConfigSchema>;
 export type HookName = "todo-continuation-enforcer" | "keyword-detector" | "ralph-loop" | "session-recovery" | "agent-usage-reminder" | "context-window-monitor" | "comment-checker" | "tool-output-truncator" | "system-prompt-injector" | "persistent-mode" | "remember-tag-processor" | "autopilot" | "ultraqa-loop" | "context-recovery" | "edit-error-recovery" | "omc-orchestrator";
 export type AgentName = "omc" | "architect" | "researcher" | "explore" | "frontendEngineer" | "documentWriter" | "multimodalLooker" | "critic" | "analyst" | "planner" | "oracle" | "librarian" | "frontend-ui-ux-engineer" | "document-writer" | "multimodal-looker";
 export declare function loadConfig(directory: string): OmoOmcsConfig;

package/dist/index.js

@@ -20592,6 +20592,14 @@ var AutopilotConfigSchema = exports_external.object({
   maxPhaseRetries: exports_external.number().min(1).max(10).optional(),
   delegationEnforcement: exports_external.enum(["strict", "warn", "off"]).optional()
 });
+var CategoryConfigSchema = exports_external.object({
+  model: exports_external.string().optional(),
+  variant: exports_external.enum(["low", "medium", "high", "max", "xhigh"]).optional(),
+  description: exports_external.string().optional(),
+  prompt_append: exports_external.string().optional(),
+  is_unstable_agent: exports_external.boolean().optional()
+});
+var CategoriesConfigSchema = exports_external.record(exports_external.string(), CategoryConfigSchema);
 var UltraQAConfigSchema = exports_external.object({
   enabled: exports_external.boolean().optional(),
   maxIterations: exports_external.number().min(1).max(100).optional(),
@@ -20644,6 +20652,7 @@ var OmoOmcsConfigSchema = exports_external.object({
   context_recovery: ContextRecoveryConfigSchema.optional(),
   edit_error_recovery: EditErrorRecoveryConfigSchema.optional(),
   tui_status: TuiStatusConfigSchema.optional(),
+  categories: CategoriesConfigSchema.optional(),
   omco_agent: exports_external.object({
     disabled: exports_external.boolean().optional(),
     planner_enabled: exports_external.boolean().optional(),
@@ -20674,16 +20683,16 @@ function loadConfig(directory) {
   }
   return {
     agents: {
-      omc: { model: "github-copilot/claude-opus-4", enabled: true },
-      architect: { model: "github-copilot/claude-opus-4", enabled: true },
-      researcher: { model: "github-copilot/claude-sonnet-4", enabled: true },
-      explore: { model: "github-copilot/claude-haiku-4", enabled: true },
-      frontendEngineer: { model: "github-copilot/claude-sonnet-4", enabled: true },
-      documentWriter: { model: "github-copilot/claude-haiku-4", enabled: true },
-      multimodalLooker: { model: "github-copilot/claude-sonnet-4", enabled: true },
-      critic: { model: "github-copilot/claude-opus-4", enabled: true },
-      analyst: { model: "github-copilot/claude-opus-4", enabled: true },
-      planner: { model: "github-copilot/claude-opus-4", enabled: true }
+      omc: { tier: "opus", enabled: true },
+      architect: { tier: "opus", enabled: true },
+      researcher: { tier: "sonnet", enabled: true },
+      explore: { tier: "haiku", enabled: true },
+      frontendEngineer: { tier: "sonnet", enabled: true },
+      documentWriter: { tier: "haiku", enabled: true },
+      multimodalLooker: { tier: "sonnet", enabled: true },
+      critic: { tier: "opus", enabled: true },
+      analyst: { tier: "opus", enabled: true },
+      planner: { tier: "opus", enabled: true }
     },
     features: {
       parallelExecution: true,
@@ -20714,11 +20723,6 @@ function loadConfig(directory) {
       defaultTier: "MEDIUM",
       escalationEnabled: true,
       maxEscalations: 2,
-      tierModels: {
-        LOW: "github-copilot/claude-haiku-4",
-        MEDIUM: "github-copilot/claude-sonnet-4",
-        HIGH: "github-copilot/claude-opus-4"
-      },
       agentOverrides: {
         architect: { tier: "HIGH", reason: "Advisory agent requires deep reasoning" },
         planner: { tier: "HIGH", reason: "Strategic planning requires deep reasoning" },
@@ -20770,7 +20774,8 @@ function loadConfig(directory) {
     },
     omco_agent: {
       disabled: false
-    }
+    },
+    categories: {}
   };
 }
 
@@ -21873,6 +21878,29 @@ function createBackgroundManager(ctx, config2, modelService) {
     }
     return count;
   };
+  const detectConfiguredProvider = async () => {
+    try {
+      const providersResp = await ctx.client.provider.list({
+        query: { directory: ctx.directory }
+      });
+      const providers = providersResp.data;
+      for (const provider of providers || []) {
+        if (provider.models && provider.models.length > 0) {
+          const modelConfig = {
+            providerID: provider.id,
+            modelID: provider.models[0].id
+          };
+          log(`Detected configured provider as fallback`, { providerID: modelConfig.providerID, modelID: modelConfig.modelID });
+          return modelConfig;
+        }
+      }
+      log(`No configured providers found`);
+      return;
+    } catch (err) {
+      log(`Failed to detect configured provider`, { error: String(err) });
+      return;
+    }
+  };
   const getParentSessionModel = async (parentSessionID) => {
     if (modelCache.has(parentSessionID)) {
       return modelCache.get(parentSessionID);
@@ -21894,11 +21922,17 @@ function createBackgroundManager(ctx, config2, modelService) {
         return model;
       }
       log(`Parent session has no assistant messages with model info`, { parentSessionID });
-      return;
     } catch (err) {
       log(`Failed to get parent session model`, { parentSessionID, error: String(err) });
-      return;
     }
+    try {
+      const configuredModel = await detectConfiguredProvider();
+      if (configuredModel) {
+        modelCache.set(parentSessionID, configuredModel);
+        return configuredModel;
+      }
+    } catch {}
+    return;
   };
   const createTask = async (parentSessionID, description, prompt, agent, model) => {
     const runningCount = getRunningCount();
@@ -21906,109 +21940,127 @@ function createBackgroundManager(ctx, config2, modelService) {
       throw new Error(`Max concurrent tasks (${defaultConcurrency}) reached. Wait for some to complete.`);
     }
     const taskId = generateTaskId();
-    const task = {
-      id: taskId,
-      status: "running",
-      description,
-      parentSessionID,
-      startedAt: Date.now()
-    };
-    tasks.set(taskId, task);
-    log(`Background task created`, { taskId, description, agent });
-    const parentModel = model || await getParentSessionModel(parentSessionID);
-    const resolvedModel = modelService ? modelService.resolveModelForAgent(agent, parentModel) : parentModel;
-    if (resolvedModel && resolvedModel !== parentModel) {
-      log(`[background-manager] Using tier-mapped model for ${agent}`, {
-        providerID: resolvedModel.providerID,
-        modelID: resolvedModel.modelID
-      });
-    }
-    (async () => {
-      try {
-        const sessionResp = await ctx.client.session.create({
-          body: {
-            parentID: parentSessionID,
-            title: `${agent}: ${description}`
-          },
-          query: { directory: ctx.directory }
+    try {
+      const parentModel = model || await getParentSessionModel(parentSessionID);
+      const resolvedModel = modelService ? modelService.resolveModelForAgent(agent, parentModel) : parentModel;
+      if (!resolvedModel) {
+        throw new Error(`[OMCO] No model available for agent "${agent}". ` + `Configure tier mapping with 'npx omco-setup'.`);
+      }
+      if (resolvedModel !== parentModel) {
+        log(`[background-manager] Using tier-mapped model for ${agent}`, {
+          providerID: resolvedModel.providerID,
+          modelID: resolvedModel.modelID
         });
-        const sessionID = sessionResp.data?.id ?? sessionResp.id;
-        if (!sessionID)
-          throw new Error("Failed to create session");
-        task.sessionID = sessionID;
-        const canonicalName = isAlias(agent) ? getCanonicalName(agent) : agent;
-        const agentDef = getAgent(canonicalName);
-        const systemPrompt = agentDef?.systemPrompt || "";
-        const fullPrompt = systemPrompt ? `${systemPrompt}
+      }
+      const task = {
+        id: taskId,
+        status: "running",
+        description,
+        parentSessionID,
+        startedAt: Date.now()
+      };
+      tasks.set(taskId, task);
+      log(`Background task created`, { taskId, description, agent });
+      (async () => {
+        try {
+          const sessionResp = await ctx.client.session.create({
+            body: {
+              parentID: parentSessionID,
+              title: `${agent}: ${description}`
+            },
+            query: { directory: ctx.directory }
+          });
+          const sessionID = sessionResp.data?.id ?? sessionResp.id;
+          if (!sessionID)
+            throw new Error("Failed to create session");
+          task.sessionID = sessionID;
+          const canonicalName = isAlias(agent) ? getCanonicalName(agent) : agent;
+          const agentDef = getAgent(canonicalName);
+          const systemPrompt = agentDef?.systemPrompt || "";
+          const fullPrompt = systemPrompt ? `${systemPrompt}
 
 ${prompt}` : prompt;
-        const promptBody = {
-          parts: [{ type: "text", text: fullPrompt }]
-        };
-        if (resolvedModel) {
-          promptBody.model = resolvedModel;
-          log(`Using model for subagent`, { taskId, ...resolvedModel });
-        }
-        let promptResp = await ctx.client.session.prompt({
-          path: { id: sessionID },
-          body: promptBody,
-          query: { directory: ctx.directory }
-        });
-        let promptData = promptResp.data;
-        if (promptResp.error) {
-          throw new Error(`Prompt failed: ${JSON.stringify(promptResp.error)}`);
-        }
-        if (promptData?.info?.error) {
-          const err = promptData.info.error;
-          const isModelError = err.name === "ProviderModelNotFoundError" || err.name === "ProviderNotFoundError" || err.name?.includes("Model") || err.name?.includes("Provider");
-          if (isModelError && parentModel && resolvedModel !== parentModel) {
-            log(`[background-manager] Model error with tier-mapped model, retrying with parent session model`, {
-              taskId,
-              error: err.name,
-              failedModel: resolvedModel,
-              fallbackModel: parentModel
-            });
-            promptBody.model = parentModel;
-            promptResp = await ctx.client.session.prompt({
-              path: { id: sessionID },
-              body: promptBody,
-              query: { directory: ctx.directory }
-            });
-            promptData = promptResp.data;
-            if (promptResp.error) {
-              throw new Error(`Prompt failed after retry: ${JSON.stringify(promptResp.error)}`);
+          const promptBody = {
+            parts: [{ type: "text", text: fullPrompt }]
+          };
+          if (resolvedModel) {
+            promptBody.model = resolvedModel;
+            log(`Using model for subagent`, { taskId, ...resolvedModel });
+          }
+          let promptResp = await ctx.client.session.prompt({
+            path: { id: sessionID },
+            body: promptBody,
+            query: { directory: ctx.directory }
+          });
+          let promptData = promptResp.data;
+          if (promptResp.error) {
+            throw new Error(`Prompt failed: ${JSON.stringify(promptResp.error)}`);
+          }
+          if (promptData?.info?.error) {
+            const err = promptData.info.error;
+            const isModelError = err.name === "ProviderModelNotFoundError" || err.name === "ProviderNotFoundError" || err.name?.includes("Model") || err.name?.includes("Provider");
+            if (isModelError && parentModel && resolvedModel !== parentModel) {
+              log(`[background-manager] Model error with tier-mapped model, retrying with parent session model`, {
+                taskId,
+                error: err.name,
+                failedModel: resolvedModel,
+                fallbackModel: parentModel
+              });
+              promptBody.model = parentModel;
+              promptResp = await ctx.client.session.prompt({
+                path: { id: sessionID },
+                body: promptBody,
+                query: { directory: ctx.directory }
+              });
+              promptData = promptResp.data;
+              if (promptResp.error) {
+                throw new Error(`Prompt failed after retry: ${JSON.stringify(promptResp.error)}`);
+              }
             }
           }
-        }
-        if (promptData?.info?.error) {
-          const err = promptData.info.error;
-          const errMsg = err.data?.message || err.name || "Unknown error";
-          throw new Error(`[${err.name}] ${errMsg}`);
-        }
-        const result = promptData?.parts?.filter((p) => p.type === "text" && p.text).map((p) => p.text).join(`
-`) || "";
-        task.result = result;
-        task.status = "completed";
-        task.completedAt = Date.now();
-        log(`Background task completed`, { taskId, duration: task.completedAt - task.startedAt });
-        ctx.client.tui.showToast({
-          body: {
-            title: "Background Task Completed",
-            message: `${description.substring(0, 40)}...`,
-            variant: "success",
-            duration: 3000
+          if (promptData?.info?.error) {
+            const err = promptData.info.error;
+            const errMsg = err.data?.message || err.name || "Unknown error";
+            throw new Error(`[${err.name}] ${errMsg}`);
           }
-        }).catch((err) => {
-          log(`Toast notification failed`, { taskId, error: String(err) });
-        });
-      } catch (err) {
-        task.status = "failed";
-        task.error = String(err);
-        task.completedAt = Date.now();
-        log(`Background task failed`, { taskId, error: task.error });
-      }
-    })();
-    return task;
+          const result = promptData?.parts?.filter((p) => p.type === "text" && p.text).map((p) => p.text).join(`
+`) || "";
+          task.result = result;
+          task.status = "completed";
+          task.completedAt = Date.now();
+          log(`Background task completed`, { taskId, duration: task.completedAt - task.startedAt });
+          ctx.client.tui.showToast({
+            body: {
+              title: "Background Task Completed",
+              message: `${description.substring(0, 40)}...`,
+              variant: "success",
+              duration: 3000
+            }
+          }).catch((err) => {
+            log(`Toast notification failed`, { taskId, error: String(err) });
+          });
+        } catch (err) {
+          task.status = "failed";
+          task.error = String(err);
+          task.completedAt = Date.now();
+          log(`Background task failed`, { taskId, error: task.error });
+        }
+      })();
+      return task;
+    } catch (err) {
+      const failedTask = {
+        id: taskId,
+        status: "failed",
+        description,
+        parentSessionID,
+        error: String(err),
+        startedAt: Date.now(),
+        completedAt: Date.now()
+      };
+      tasks.set(taskId, failedTask);
+      log(`Background task failed during creation`, { taskId, error: String(err) });
+      return failedTask;
+    }
   };
   const getTask = (taskId) => {
     return tasks.get(taskId);
@@ -34475,14 +34527,243 @@ Use \`background_output\` to get results. Prompts MUST be in English.`,
   };
 }
 
+// src/categories/constants.ts
+var VISUAL_CATEGORY_PROMPT_APPEND = `<Category_Context>
+You are working on VISUAL/UI tasks.
+
+Design-first mindset:
+- Bold aesthetic choices over safe defaults
+- Unexpected layouts, asymmetry, grid-breaking elements
+- Distinctive typography (avoid: Arial, Inter, Roboto, Space Grotesk)
+- Cohesive color palettes with sharp accents
+- High-impact animations with staggered reveals
+- Atmosphere: gradient meshes, noise textures, layered transparencies
+
+AVOID: Generic fonts, purple gradients on white, predictable layouts, cookie-cutter patterns.
+</Category_Context>`;
+var ULTRABRAIN_CATEGORY_PROMPT_APPEND = `<Category_Context>
+You are working on COMPLEX ARCHITECTURE / DEEP REASONING tasks.
+
+Strategic advisor mindset:
+- Bias toward simplicity: least complex solution that fulfills requirements
+- Leverage existing code/patterns over new components
+- Prioritize developer experience and maintainability
+- One clear recommendation with effort estimate (Quick/Short/Medium/Large)
+- Signal when advanced approach warranted
+
+Response format:
+- Bottom line (2-3 sentences)
+- Action plan (numbered steps)
+- Risks and mitigations (if relevant)
+</Category_Context>`;
+var ARTISTRY_CATEGORY_PROMPT_APPEND = `<Category_Context>
+You are working on HIGHLY CREATIVE / ARTISTIC tasks.
+
+Artistic genius mindset:
+- Push far beyond conventional boundaries
+- Explore radical, unconventional directions
+- Surprise and delight: unexpected twists, novel combinations
+- Rich detail and vivid expression
+- Break patterns deliberately when it serves the creative vision
+
+Approach:
+- Generate diverse, bold options first
+- Embrace ambiguity and wild experimentation
+- Balance novelty with coherence
+- This is for tasks requiring exceptional creativity
+</Category_Context>`;
+var QUICK_CATEGORY_PROMPT_APPEND = `<Category_Context>
+You are working on SMALL / QUICK tasks.
+
+Efficient execution mindset:
+- Fast, focused, minimal overhead
+- Get to the point immediately
+- No over-engineering
+- Simple solutions for simple problems
+
+Approach:
+- Minimal viable implementation
+- Skip unnecessary abstractions
+- Direct and concise
+</Category_Context>
+
+<Caller_Warning>
+THIS CATEGORY USES A LESS CAPABLE MODEL (haiku tier).
+
+The model executing this task has LIMITED reasoning capacity. Your prompt MUST be:
+
+**EXHAUSTIVELY EXPLICIT** - Leave NOTHING to interpretation:
+1. MUST DO: List every required action as atomic, numbered steps
+2. MUST NOT DO: Explicitly forbid likely mistakes and deviations
+3. EXPECTED OUTPUT: Describe exact success criteria with concrete examples
+
+**WHY THIS MATTERS:**
+- Less capable models WILL deviate without explicit guardrails
+- Vague instructions \u2192 unpredictable results
+- Implicit expectations \u2192 missed requirements
+
+**PROMPT STRUCTURE (MANDATORY):**
+\`\`\`
+TASK: [One-sentence goal]
+
+MUST DO:
+1. [Specific action with exact details]
+2. [Another specific action]
+...
+
+MUST NOT DO:
+- [Forbidden action + why]
+- [Another forbidden action]
+...
+
+EXPECTED OUTPUT:
+- [Exact deliverable description]
+- [Success criteria / verification method]
+\`\`\`
+
+If your prompt lacks this structure, REWRITE IT before delegating.
+</Caller_Warning>`;
+var UNSPECIFIED_LOW_CATEGORY_PROMPT_APPEND = `<Category_Context>
+You are working on tasks that don't fit specific categories but require moderate effort.
+
+<Selection_Gate>
+BEFORE selecting this category, VERIFY ALL conditions:
+1. Task does NOT fit: quick (trivial), visual-engineering (UI), ultrabrain (deep logic), artistry (creative), writing (docs)
+2. Task requires more than trivial effort but is NOT system-wide
+3. Scope is contained within a few files/modules
+
+If task fits ANY other category, DO NOT select unspecified-low.
+This is NOT a default choice - it's for genuinely unclassifiable moderate-effort work.
+</Selection_Gate>
+</Category_Context>
+
+<Caller_Warning>
+THIS CATEGORY USES A MID-TIER MODEL (sonnet tier).
+
+**PROVIDE CLEAR STRUCTURE:**
+1. MUST DO: Enumerate required actions explicitly
+2. MUST NOT DO: State forbidden actions to prevent scope creep
+3. EXPECTED OUTPUT: Define concrete success criteria
+</Caller_Warning>`;
+var UNSPECIFIED_HIGH_CATEGORY_PROMPT_APPEND = `<Category_Context>
+You are working on tasks that don't fit specific categories but require substantial effort.
+
+<Selection_Gate>
+BEFORE selecting this category, VERIFY ALL conditions:
+1. Task does NOT fit: quick (trivial), visual-engineering (UI), ultrabrain (deep logic), artistry (creative), writing (docs)
+2. Task requires substantial effort across multiple systems/modules
+3. Changes have broad impact or require careful coordination
+4. NOT just "complex" - must be genuinely unclassifiable AND high-effort
+
+If task fits ANY other category, DO NOT select unspecified-high.
+If task is unclassifiable but moderate-effort, use unspecified-low instead.
+</Selection_Gate>
+</Category_Context>`;
+var WRITING_CATEGORY_PROMPT_APPEND = `<Category_Context>
+You are working on WRITING / PROSE tasks.
+
+Wordsmith mindset:
+- Clear, flowing prose
+- Appropriate tone and voice
+- Engaging and readable
+- Proper structure and organization
+
+Approach:
+- Understand the audience
+- Draft with care
+- Polish for clarity and impact
+- Documentation, READMEs, articles, technical writing
+</Category_Context>`;
+var DEFAULT_CATEGORIES = {
+  "visual-engineering": {
+    model: "opus",
+    description: "Frontend, UI/UX, design, styling, animation"
+  },
+  ultrabrain: {
+    model: "opus",
+    variant: "high",
+    description: "Deep logical reasoning, complex architecture decisions requiring extensive analysis"
+  },
+  artistry: {
+    model: "opus",
+    variant: "max",
+    description: "Highly creative/artistic tasks, novel ideas"
+  },
+  quick: {
+    model: "haiku",
+    description: "Trivial tasks - single file changes, typo fixes, simple modifications"
+  },
+  "unspecified-low": {
+    model: "sonnet",
+    description: "Tasks that don't fit other categories, moderate effort required"
+  },
+  "unspecified-high": {
+    model: "opus",
+    variant: "max",
+    description: "Tasks that don't fit other categories, high effort required"
+  },
+  writing: {
+    model: "sonnet",
+    description: "Documentation, prose, technical writing"
+  }
+};
+var CATEGORY_PROMPT_APPENDS = {
+  "visual-engineering": VISUAL_CATEGORY_PROMPT_APPEND,
+  ultrabrain: ULTRABRAIN_CATEGORY_PROMPT_APPEND,
+  artistry: ARTISTRY_CATEGORY_PROMPT_APPEND,
+  quick: QUICK_CATEGORY_PROMPT_APPEND,
+  "unspecified-low": UNSPECIFIED_LOW_CATEGORY_PROMPT_APPEND,
+  "unspecified-high": UNSPECIFIED_HIGH_CATEGORY_PROMPT_APPEND,
+  writing: WRITING_CATEGORY_PROMPT_APPEND
+};
+var CATEGORY_DESCRIPTIONS = {
+  "visual-engineering": "Frontend, UI/UX, design, styling, animation",
+  ultrabrain: "Deep logical reasoning, complex architecture decisions requiring extensive analysis",
+  artistry: "Highly creative/artistic tasks, novel ideas",
+  quick: "Trivial tasks - single file changes, typo fixes, simple modifications",
+  "unspecified-low": "Tasks that don't fit other categories, moderate effort required",
+  "unspecified-high": "Tasks that don't fit other categories, high effort required",
+  writing: "Documentation, prose, technical writing"
+};
+// src/categories/resolver.ts
+function resolveCategoryConfig(categoryName, userCategories) {
+  const defaultConfig = DEFAULT_CATEGORIES[categoryName];
+  const userConfig = userCategories?.[categoryName];
+  const defaultPromptAppend = CATEGORY_PROMPT_APPENDS[categoryName] ?? "";
+  if (!defaultConfig && !userConfig) {
+    return null;
+  }
+  const config3 = {
+    ...defaultConfig,
+    ...userConfig
+  };
+  const tier = config3.model ?? "sonnet";
+  let promptAppend = defaultPromptAppend;
+  if (userConfig?.prompt_append) {
+    promptAppend = defaultPromptAppend ? defaultPromptAppend + `
+
+` + userConfig.prompt_append : userConfig.prompt_append;
+  }
+  return { config: config3, promptAppend, tier };
+}
+function getAvailableCategories(userCategories) {
+  const allCategories = { ...DEFAULT_CATEGORIES, ...userCategories };
+  return Object.keys(allCategories);
+}
 // src/tools/call-omco-agent.ts
-function createCallOmcoAgent(ctx, manager, modelService) {
+function createCallOmcoAgent(ctx, manager, modelService, userCategories) {
   const agentNames = listAgentNames();
   const agentList = agentNames.map((name) => {
     const agent = getAgent(name);
     const aliasNote = isAlias(name) ? ` (alias for ${getCanonicalName(name)})` : "";
     return `- ${name}${aliasNote}: ${agent?.description || "Agent"}`;
   }).join(`
+`);
+  const categoryNames = getAvailableCategories(userCategories);
+  const categoryList = categoryNames.map((name) => {
+    const desc = CATEGORY_DESCRIPTIONS[name] || userCategories?.[name]?.description || "Category";
+    return `- ${name}: ${desc}`;
+  }).join(`
 `);
   return tool({
     description: `Spawn specialized agent for delegation. run_in_background REQUIRED (true=async with task_id, false=sync).
@@ -34490,38 +34771,119 @@ function createCallOmcoAgent(ctx, manager, modelService) {
 Available agents:
 ${agentList}
 
+Available categories:
+${categoryList}
+
 Prompts MUST be in English. Use \`background_output\` for async results.`,
     args: {
       description: tool.schema.string().describe("Short description of task"),
       prompt: tool.schema.string().describe("Task prompt"),
-      subagent_type: tool.schema.string().describe(`Agent type to spawn. Available: ${agentNames.join(", ")}`),
+      subagent_type: tool.schema.string().optional().describe(`Agent type to spawn. Available: ${agentNames.join(", ")}`),
+      category: tool.schema.string().optional().describe(`Category for delegation (e.g., 'quick', 'visual-engineering', 'ultrabrain'). Mutually exclusive with subagent_type.`),
       run_in_background: tool.schema.boolean().describe("Run async (true) or sync (false)"),
       session_id: tool.schema.string().optional().describe("Existing session to continue")
     },
     async execute(args, context) {
-      const { description, prompt, subagent_type, run_in_background } = args;
-      const agent = getAgent(subagent_type);
-      if (!agent) {
+      const { description, prompt, subagent_type, category, run_in_background } = args;
+      if (subagent_type && category) {
+        return JSON.stringify({
+          status: "failed",
+          error: "subagent_type and category are mutually exclusive. Provide only one."
+        });
+      }
+      if (!subagent_type && !category) {
         return JSON.stringify({
           status: "failed",
-          error: `Unknown agent type: ${subagent_type}. Available: ${listAgentNames().join(", ")}`
+          error: "Either subagent_type or category must be provided."
         });
       }
-      const enhancedPrompt = `${agent.systemPrompt}
+      let enhancedPrompt;
+      let tierForResolution;
+      let agentTypeForLogging;
+      if (category) {
+        const resolved = resolveCategoryConfig(category, userCategories);
+        if (!resolved) {
+          return JSON.stringify({
+            status: "failed",
+            error: `Unknown category: ${category}. Available: ${getAvailableCategories(userCategories).join(", ")}`
+          });
+        }
+        enhancedPrompt = resolved.promptAppend ? `${resolved.promptAppend}
+
+---
+
+${prompt}` : prompt;
+        tierForResolution = resolved.tier;
+        agentTypeForLogging = `category:${category}`;
+        log(`[call-omco-agent] Using category delegation`, { category, tier: tierForResolution });
+      } else {
+        const agent = getAgent(subagent_type);
+        if (!agent) {
+          return JSON.stringify({
+            status: "failed",
+            error: `Unknown agent type: ${subagent_type}. Available: ${listAgentNames().join(", ")}`
+          });
+        }
+        enhancedPrompt = `${agent.systemPrompt}
 
 ---
 
 ${prompt}`;
+        agentTypeForLogging = subagent_type;
+      }
       const parentModel = await manager.getParentSessionModel(context.sessionID);
-      const resolvedModel = modelService ? modelService.resolveModelForAgent(subagent_type, parentModel) : parentModel;
-      if (resolvedModel && resolvedModel !== parentModel) {
-        log(`[call-omco-agent] Using tier-mapped model for ${subagent_type}`, {
-          providerID: resolvedModel.providerID,
-          modelID: resolvedModel.modelID
-        });
+      let resolvedModel = parentModel;
+      if (modelService) {
+        try {
+          if (category && tierForResolution) {
+            const categoryModel = modelService.resolveModelForCategory(tierForResolution, parentModel);
+            if (categoryModel) {
+              resolvedModel = categoryModel;
+              if (resolvedModel && resolvedModel !== parentModel) {
+                log(`[call-omco-agent] Using tier-mapped model for category ${category}`, {
+                  tier: tierForResolution,
+                  providerID: resolvedModel.providerID,
+                  modelID: resolvedModel.modelID
+                });
+              }
+            } else if (!parentModel) {
+              const errorMsg = `[OMCO] Cannot resolve model for category "${category}" (tier: ${tierForResolution}).
+
+` + `No tier mapping configured. Run one of:
+` + `  1. npx omco-setup (interactive setup)
+` + `  2. Add tierDefaults to ~/.config/opencode/omco.json:
+` + `     {
+` + `       "model_mapping": {
+` + `         "tierDefaults": {
+` + `           "haiku": "openai/gpt-4o-mini",
+` + `           "sonnet": "openai/gpt-4o",
+` + `           "opus": "openai/o1"
+` + `         }
+` + `       }
+` + `     }`;
+              return JSON.stringify({
+                status: "failed",
+                error: errorMsg
+              });
+            }
+          } else if (subagent_type) {
+            resolvedModel = modelService.resolveModelForAgentOrThrow(subagent_type, parentModel);
+            if (resolvedModel && resolvedModel !== parentModel) {
+              log(`[call-omco-agent] Using tier-mapped model for ${subagent_type}`, {
+                providerID: resolvedModel.providerID,
+                modelID: resolvedModel.modelID
+              });
+            }
+          }
+        } catch (err) {
+          return JSON.stringify({
+            status: "failed",
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
       }
       if (run_in_background) {
-        const task = await manager.createTask(context.sessionID, description, enhancedPrompt, subagent_type, resolvedModel);
+        const task = await manager.createTask(context.sessionID, description, enhancedPrompt, agentTypeForLogging, resolvedModel);
         return JSON.stringify({
           task_id: task.id,
           session_id: task.sessionID,
@@ -34533,7 +34895,7 @@ ${prompt}`;
         const sessionResp = await ctx.client.session.create({
           body: {
             parentID: context.sessionID,
-            title: `${subagent_type}: ${description}`
+            title: `${agentTypeForLogging}: ${description}`
           },
           query: { directory: ctx.directory }
         });
@@ -34545,7 +34907,7 @@ ${prompt}`;
         };
         if (resolvedModel) {
           promptBody.model = resolvedModel;
-          log(`Using resolved model for sync agent call`, { subagent_type, ...resolvedModel });
+          log(`Using resolved model for sync agent call`, { agentType: agentTypeForLogging, ...resolvedModel });
         }
         let promptResp = await ctx.client.session.prompt({
           path: { id: sessionID },
@@ -34735,12 +35097,64 @@ function createModelResolutionService(modelMappingConfig, agentOverrides) {
     }
     return fallbackModel;
   };
+  const resolveModelForAgentOrThrow = (agentName, fallbackModel) => {
+    const result = resolveModelForAgent(agentName, fallbackModel);
+    if (result)
+      return result;
+    const tierDefaults2 = resolver.getTierDefaults();
+    const hasConfiguredTiers2 = Object.values(tierDefaults2).some((m) => m.includes("/"));
+    let errorMessage = `[OMCO] Cannot resolve model for agent "${agentName}".`;
+    if (!hasConfiguredTiers2) {
+      errorMessage += `
+
+No tier mapping configured. Run one of:
+` + `  1. npx omco-setup (interactive setup)
+` + `  2. Add tierDefaults to ~/.config/opencode/omco.json:
+` + `     {
+` + `       "model_mapping": {
+` + `         "tierDefaults": {
+` + `           "haiku": "openai/gpt-4o-mini",
+` + `           "sonnet": "openai/gpt-4o",
+` + `           "opus": "openai/o1"
+` + `         }
+` + `       }
+` + `     }`;
+    } else {
+      errorMessage += `
+
+Tier mapping is configured but no fallback model available.
+` + `This usually means the parent session hasn't started yet.
+` + `Try sending a message first to establish the session model.`;
+    }
+    throw new Error(errorMessage);
+  };
   const isTierMappingConfigured = () => {
     return hasConfiguredTiers;
   };
+  const resolveModelForCategory = (categoryTier, fallbackModel) => {
+    const tierDefaults2 = resolver.getTierDefaults();
+    const mappedModel = tierDefaults2[categoryTier];
+    if (mappedModel) {
+      const modelConfig = parseModelString(mappedModel);
+      if (modelConfig) {
+        if (debugLogging) {
+          log(`[model-resolution] Resolved category tier "${categoryTier}": ${mappedModel}`);
+        }
+        return modelConfig;
+      }
+    }
+    if (debugLogging) {
+      log(`[model-resolution] No mapping for category tier "${categoryTier}", using fallback`, {
+        fallback: fallbackModel ? `${fallbackModel.providerID}/${fallbackModel.modelID}` : "none"
+      });
+    }
+    return fallbackModel;
+  };
   return {
     resolveModelForAgent,
-    isTierMappingConfigured
+    resolveModelForAgentOrThrow,
+    isTierMappingConfigured,
+    resolveModelForCategory
   };
 }
 
@@ -38635,7 +39049,7 @@ var OmoOmcsPlugin = async (ctx) => {
   }
   const backgroundManager = createBackgroundManager(ctx, pluginConfig.background_task, modelService);
   const backgroundTools = createBackgroundTools(backgroundManager, ctx.client);
-  const callOmcoAgent = createCallOmcoAgent(ctx, backgroundManager, modelService);
+  const callOmcoAgent = createCallOmcoAgent(ctx, backgroundManager, modelService, pluginConfig.categories);
   const systemPromptInjector = createSystemPromptInjector(ctx);
   const skillInjector = createSkillInjector(ctx);
   const ralphLoop = createRalphLoopHook(ctx, {

package/dist/tools/call-omco-agent.d.ts

@@ -1,4 +1,5 @@
 import { type PluginInput, type ToolDefinition } from "@opencode-ai/plugin";
 import type { BackgroundManager } from "./background-manager";
 import type { ModelResolutionService } from "./model-resolution-service";
-export declare function createCallOmcoAgent(ctx: PluginInput, manager: BackgroundManager, modelService?: ModelResolutionService): ToolDefinition;
+import type { CategoriesConfig } from "../categories/types";
+export declare function createCallOmcoAgent(ctx: PluginInput, manager: BackgroundManager, modelService?: ModelResolutionService, userCategories?: CategoriesConfig): ToolDefinition;

package/dist/tools/model-resolution-service.d.ts

@@ -27,10 +27,25 @@ export interface ModelResolutionService {
      * @returns Resolved ModelConfig or undefined if should use fallback
      */
     resolveModelForAgent(agentName: string, fallbackModel?: ModelConfig): ModelConfig | undefined;
+    /**
+     * Resolve model for an agent, always returning a result or throwing
+     * @param agentName - Name of the agent (canonical or alias)
+     * @param fallbackModel - Parent session model to use if resolution fails
+     * @returns Resolved ModelConfig (never undefined)
+     * @throws Error with actionable message if model cannot be resolved
+     */
+    resolveModelForAgentOrThrow(agentName: string, fallbackModel?: ModelConfig): ModelConfig;
     /**
      * Check if tier mapping is configured (tierDefaults has provider/model format)
      */
     isTierMappingConfigured(): boolean;
+    /**
+     * Resolve model for a category-based tier (abstract tier name)
+     * @param categoryTier - Abstract tier name (haiku, sonnet, opus)
+     * @param fallbackModel - Parent session model to use if resolution fails
+     * @returns Resolved ModelConfig or undefined if no mapping found
+     */
+    resolveModelForCategory(categoryTier: string, fallbackModel?: ModelConfig): ModelConfig | undefined;
 }
 /**
  * Create a ModelResolutionService instance

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-claudecode-opencode",
-  "version": "0.6.11",
+  "version": "0.7.0",
   "description": "OpenCode port of oh-my-claudecode - Multi-agent orchestration plugin (omco)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",