oh-my-claudecode-opencode 0.6.2 → 0.6.4

package/assets/skills/version.md

@@ -0,0 +1,69 @@
+---
+name: version
+description: Check OMCO plugin version and update status
+user-invocable: true
+---
+
+# Version Check Skill
+
+Display the current OMCO plugin version and check for updates.
+
+## What to Do
+
+When user invokes this skill, run the following checks:
+
+### 1. Check Installed Version
+
+```bash
+# Read version from installed location
+cat ~/.config/opencode/node_modules/oh-my-claudecode-opencode/package.json 2>/dev/null | grep '"version"' | head -1
+```
+
+### 2. Check Development Version (if in dev directory)
+
+```bash
+# If in oh-my-claudecode-opencode project directory
+cat package.json 2>/dev/null | grep '"version"' | head -1
+```
+
+### 3. Check Latest Version on npm
+
+```bash
+npm view oh-my-claudecode-opencode version 2>/dev/null
+```
+
+## Output Format
+
+Present the information in a clear table:
+
+| Location | Version |
+|----------|---------|
+| Installed | X.X.X |
+| Development | X.X.X (if applicable) |
+| npm Latest | X.X.X |
+
+### Status Indicators
+
+- **Up to date**: Installed version matches npm latest
+- **Update available**: npm has newer version
+- **Ahead of npm**: Local version is higher (pre-release or unpublished)
+- **Mismatch**: Development and installed versions differ
+
+## Update Instructions
+
+If update is available:
+```bash
+cd ~/.config/opencode && npm install oh-my-claudecode-opencode@latest
+```
+
+If development version differs from installed:
+```bash
+# From development directory
+bun run build
+cp -r dist/ ~/.config/opencode/node_modules/oh-my-claudecode-opencode/dist/
+cp package.json ~/.config/opencode/node_modules/oh-my-claudecode-opencode/package.json
+```
+
+## After Update
+
+Remind users to restart OpenCode for changes to take effect.

package/dist/config/model-resolver.d.ts

@@ -22,13 +22,29 @@ export interface ModelResolutionResult {
     source: "per-agent-override" | "tier-default" | "hardcoded-fallback";
     originalTier?: ModelTier;
 }
+/**
+ * Default tier-to-model mapping.
+ * These use generic names - configure model_mapping.tierDefaults in
+ * ~/.config/opencode/oh-my-opencode.json for your specific provider.
+ *
+ * Example config:
+ * {
+ *   "model_mapping": {
+ *     "tierDefaults": {
+ *       "haiku": "google/gemini-2.0-flash",
+ *       "sonnet": "anthropic/claude-sonnet-4",
+ *       "opus": "anthropic/claude-opus-4"
+ *     }
+ *   }
+ * }
+ */
 export declare const HARDCODED_TIER_DEFAULTS: TierModelMapping;
 /**
- * Check if model follows "provider/model-name" pattern
+ * Check if model follows "provider/model-name" pattern or is a simple tier name
  */
 export declare function isValidModelFormat(model: string): boolean;
 /**
- * Log warning if invalid format
+ * Log warning if invalid format (skip for simple tier names)
  */
 export declare function validateModelFormat(model: string, context: string): void;
 export declare class ModelResolver {

package/dist/index.js

@@ -9221,7 +9221,7 @@ class Doc {
 var version = {
   major: 4,
   minor: 3,
-  patch: 6
+  patch: 5
 };
 
 // node_modules/zod/v4/core/schemas.js
@@ -10507,7 +10507,7 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
         if (keyResult instanceof Promise) {
           throw new Error("Async schemas not supported in object keys currently");
         }
-        const checkNumericKey = typeof key === "string" && number.test(key) && keyResult.issues.length;
+        const checkNumericKey = typeof key === "string" && number.test(key) && keyResult.issues.length && keyResult.issues.some((iss) => iss.code === "invalid_type" && iss.expected === "number");
         if (checkNumericKey) {
           const retryResult = def.keyType._zod.run({ value: Number(key), issues: [] }, ctx);
           if (retryResult instanceof Promise) {
@@ -17878,7 +17878,7 @@ function finalize(ctx, schema) {
           }
         }
       }
-      if (refSchema.$ref && refSeen.def) {
+      if (refSchema.$ref) {
         for (const key in schema2) {
           if (key === "$ref" || key === "allOf")
             continue;
@@ -21669,9 +21669,10 @@ function generateTaskId() {
   taskCounter++;
   return `bg_${Date.now().toString(36)}_${taskCounter.toString(36)}`;
 }
-function createBackgroundManager(ctx, config2) {
+function createBackgroundManager(ctx, config2, modelService) {
   const tasks = new Map;
   const defaultConcurrency = config2?.defaultConcurrency ?? 5;
+  const modelCache = new Map;
   const getRunningCount = (parentSessionID) => {
     let count = 0;
     for (const task of tasks.values()) {
@@ -21683,7 +21684,34 @@ function createBackgroundManager(ctx, config2) {
     }
     return count;
   };
-  const createTask = async (parentSessionID, description, prompt, agent) => {
+  const getParentSessionModel = async (parentSessionID) => {
+    if (modelCache.has(parentSessionID)) {
+      return modelCache.get(parentSessionID);
+    }
+    try {
+      const messagesResp = await ctx.client.session.messages({
+        path: { id: parentSessionID },
+        query: { directory: ctx.directory }
+      });
+      const messages = messagesResp.data;
+      const assistantMsg = messages?.find((m) => m.info.role === "assistant" && m.info.providerID && m.info.modelID);
+      if (assistantMsg?.info.providerID && assistantMsg?.info.modelID) {
+        const model = {
+          providerID: assistantMsg.info.providerID,
+          modelID: assistantMsg.info.modelID
+        };
+        modelCache.set(parentSessionID, model);
+        log(`Got parent session model from messages`, { parentSessionID, ...model });
+        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;
+    }
+  };
+  const createTask = async (parentSessionID, description, prompt, agent, model) => {
     const runningCount = getRunningCount();
     if (runningCount >= defaultConcurrency) {
       throw new Error(`Max concurrent tasks (${defaultConcurrency}) reached. Wait for some to complete.`);
@@ -21698,6 +21726,14 @@ function createBackgroundManager(ctx, config2) {
     };
     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({
@@ -21717,19 +21753,28 @@ function createBackgroundManager(ctx, config2) {
         const fullPrompt = systemPrompt ? `${systemPrompt}
 
 ${prompt}` : prompt;
-        await ctx.client.session.prompt({
+        const promptBody = {
+          parts: [{ type: "text", text: fullPrompt }]
+        };
+        if (resolvedModel) {
+          promptBody.model = resolvedModel;
+          log(`Using parent model for subagent`, { taskId, ...resolvedModel });
+        }
+        const promptResp = await ctx.client.session.prompt({
           path: { id: sessionID },
-          body: {
-            parts: [{ type: "text", text: fullPrompt }]
-          },
+          body: promptBody,
           query: { directory: ctx.directory }
         });
-        const messagesResp = await ctx.client.session.messages({
-          path: { id: sessionID }
-        });
-        const messages = messagesResp.data ?? [];
-        const lastAssistant = [...messages].reverse().find((m) => m.info?.role === "assistant");
-        const result = lastAssistant?.parts?.filter((p) => p.type === "text" && p.text).map((p) => p.text).join(`
+        const 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 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";
@@ -21770,6 +21815,14 @@ ${prompt}` : prompt;
       return false;
     task.status = "cancelled";
     task.completedAt = Date.now();
+    if (task.sessionID) {
+      ctx.client.session.abort({
+        path: { id: task.sessionID },
+        query: { directory: ctx.directory }
+      }).catch((err) => {
+        log(`Failed to abort session for task ${taskId}`, { error: String(err) });
+      });
+    }
     log(`Background task cancelled`, { taskId });
     return true;
   };
@@ -21781,6 +21834,14 @@ ${prompt}` : prompt;
           task.status = "cancelled";
           task.completedAt = Date.now();
           count++;
+          if (task.sessionID) {
+            ctx.client.session.abort({
+              path: { id: task.sessionID },
+              query: { directory: ctx.directory }
+            }).catch((err) => {
+              log(`Failed to abort session for task ${task.id}`, { error: String(err) });
+            });
+          }
         }
       }
     }
@@ -21808,7 +21869,8 @@ ${prompt}` : prompt;
     getTasksByParentSession,
     cancelTask,
     cancelAllTasks,
-    waitForTask
+    waitForTask,
+    getParentSessionModel
   };
 }
 
@@ -34201,7 +34263,7 @@ Use \`background_output\` to get results. Prompts MUST be in English.`,
 }
 
 // src/tools/call-omco-agent.ts
-function createCallOmcoAgent(ctx, manager) {
+function createCallOmcoAgent(ctx, manager, modelService) {
   const agentNames = listAgentNames();
   const agentList = agentNames.map((name) => {
     const agent = getAgent(name);
@@ -34237,8 +34299,16 @@ Prompts MUST be in English. Use \`background_output\` for async results.`,
 ---
 
 ${prompt}`;
+      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
+        });
+      }
       if (run_in_background) {
-        const task = await manager.createTask(context.sessionID, description, enhancedPrompt, subagent_type);
+        const task = await manager.createTask(context.sessionID, description, enhancedPrompt, subagent_type, resolvedModel);
         return JSON.stringify({
           task_id: task.id,
           session_id: task.sessionID,
@@ -34257,19 +34327,36 @@ ${prompt}`;
         const sessionID = sessionResp.data?.id ?? sessionResp.id;
         if (!sessionID)
           throw new Error("Failed to create session");
-        await ctx.client.session.prompt({
+        const promptBody = {
+          parts: [{ type: "text", text: enhancedPrompt }]
+        };
+        if (resolvedModel) {
+          promptBody.model = resolvedModel;
+          log(`Using resolved model for sync agent call`, { subagent_type, ...resolvedModel });
+        }
+        const promptResp = await ctx.client.session.prompt({
           path: { id: sessionID },
-          body: {
-            parts: [{ type: "text", text: enhancedPrompt }]
-          },
+          body: promptBody,
           query: { directory: ctx.directory }
         });
-        const messagesResp = await ctx.client.session.messages({
-          path: { id: sessionID }
-        });
-        const messages = messagesResp.data ?? [];
-        const lastAssistant = [...messages].reverse().find((m) => m.info?.role === "assistant");
-        const result = lastAssistant?.parts?.filter((p) => p.type === "text" && p.text).map((p) => p.text).join(`
+        if (promptResp.error) {
+          return JSON.stringify({
+            session_id: sessionID,
+            status: "failed",
+            error: `Prompt failed: ${JSON.stringify(promptResp.error)}`
+          });
+        }
+        const promptData = promptResp.data;
+        if (promptData?.info?.error) {
+          const err = promptData.info.error;
+          const errMsg = err.data?.message || err.name || "Unknown error";
+          return JSON.stringify({
+            session_id: sessionID,
+            status: "failed",
+            error: `[${err.name}] ${errMsg}`
+          });
+        }
+        const result = promptData?.parts?.filter((p) => p.type === "text" && p.text).map((p) => p.text).join(`
 `) || "";
         return JSON.stringify({
           session_id: sessionID,
@@ -34288,16 +34375,20 @@ ${prompt}`;
 
 // src/config/model-resolver.ts
 var HARDCODED_TIER_DEFAULTS = {
-  haiku: "github-copilot/claude-haiku-4",
-  sonnet: "github-copilot/claude-sonnet-4",
-  opus: "github-copilot/claude-opus-4"
+  haiku: "haiku",
+  sonnet: "sonnet",
+  opus: "opus"
 };
+var SIMPLE_TIER_NAMES = new Set(["haiku", "sonnet", "opus"]);
 function isValidModelFormat(model) {
+  if (SIMPLE_TIER_NAMES.has(model.toLowerCase())) {
+    return true;
+  }
   return /^[a-zA-Z0-9_-]+\/[a-zA-Z0-9_.-]+$/.test(model);
 }
 function validateModelFormat(model, context) {
   if (!isValidModelFormat(model)) {
-    warn(`[model-resolver] [${context}] Model "${model}" does not follow "provider/model-name" format`);
+    warn(`[model-resolver] [${context}] Model "${model}" does not follow "provider/model-name" format. Configure model_mapping.tierDefaults in oh-my-opencode.json`);
   }
 }
 
@@ -34361,6 +34452,51 @@ class ModelResolver {
   }
 }
 
+// src/tools/model-resolution-service.ts
+function parseModelString(model) {
+  if (!model.includes("/")) {
+    return;
+  }
+  const [providerID, ...rest] = model.split("/");
+  const modelID = rest.join("/");
+  if (!providerID || !modelID) {
+    return;
+  }
+  return { providerID, modelID };
+}
+function createModelResolutionService(modelMappingConfig, agentOverrides) {
+  const resolver = new ModelResolver(modelMappingConfig);
+  const debugLogging = modelMappingConfig?.debugLogging ?? false;
+  const tierDefaults = resolver.getTierDefaults();
+  const hasConfiguredTiers = Object.values(tierDefaults).some((m) => m.includes("/"));
+  const resolveModelForAgent = (agentName, fallbackModel) => {
+    const agentDef = getAgent(agentName);
+    const agentTier = agentDef?.model;
+    const agentOverride = agentOverrides?.[agentName];
+    const resolution = resolver.resolve(agentName, agentTier, agentOverride);
+    const modelConfig = parseModelString(resolution.model);
+    if (modelConfig) {
+      if (debugLogging) {
+        log(`[model-resolution] Resolved ${agentName}: ${resolution.model} (source: ${resolution.source})`);
+      }
+      return modelConfig;
+    }
+    if (debugLogging) {
+      log(`[model-resolution] ${agentName}: No provider mapping for "${resolution.model}", using fallback`, {
+        fallback: fallbackModel ? `${fallbackModel.providerID}/${fallbackModel.modelID}` : "none"
+      });
+    }
+    return fallbackModel;
+  };
+  const isTierMappingConfigured = () => {
+    return hasConfiguredTiers;
+  };
+  return {
+    resolveModelForAgent,
+    isTierMappingConfigured
+  };
+}
+
 // src/skills/index.ts
 import { join as join4, dirname as dirname2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -38229,13 +38365,30 @@ function getAgentEmoji(agentName) {
   return emojiMap[agentName] || "\uD83E\uDD16";
 }
 
+// src/state/session-pause-state.ts
+var pauseStates = new Map;
+function isSessionPaused(sessionId) {
+  return pauseStates.get(sessionId)?.isPaused ?? false;
+}
+function resumeSession(sessionId) {
+  const state = pauseStates.get(sessionId);
+  if (state?.isPaused) {
+    log(`Session resumed`, { sessionId, wasPausedFor: Date.now() - (state.pausedAt ?? 0) });
+  }
+  pauseStates.delete(sessionId);
+}
+
 // src/index.ts
 var OmoOmcsPlugin = async (ctx) => {
   const pluginConfig = loadConfig(ctx.directory);
   console.log("[omco] Config loaded:", pluginConfig);
-  const backgroundManager = createBackgroundManager(ctx, pluginConfig.background_task);
+  const modelService = createModelResolutionService(pluginConfig.model_mapping, pluginConfig.agents);
+  if (modelService.isTierMappingConfigured()) {
+    log("[omco] Model tier mapping configured - agents will use tier-specific models");
+  }
+  const backgroundManager = createBackgroundManager(ctx, pluginConfig.background_task, modelService);
   const backgroundTools = createBackgroundTools(backgroundManager, ctx.client);
-  const callOmcoAgent = createCallOmcoAgent(ctx, backgroundManager);
+  const callOmcoAgent = createCallOmcoAgent(ctx, backgroundManager, modelService);
   const systemPromptInjector = createSystemPromptInjector(ctx);
   const skillInjector = createSkillInjector(ctx);
   const ralphLoop = createRalphLoopHook(ctx, {
@@ -38335,6 +38488,10 @@ var OmoOmcsPlugin = async (ctx) => {
       } else {
         systemPromptInjector.clearSkillInjection(input.sessionID);
       }
+      if (isSessionPaused(input.sessionID)) {
+        resumeSession(input.sessionID);
+        log("[session] Auto-resumed on user prompt", { sessionID: input.sessionID });
+      }
       await autopilot["chat.message"](input, output);
       await ultraqaLoop["chat.message"](input, output);
     },

package/dist/state/session-pause-state.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Shared session pause state for coordinating abort handling across hooks.
+ * When user presses ESC (triggers MessageAbortedError), the session is paused
+ * and remains paused until explicitly resumed or user sends a new prompt.
+ */
+interface SessionPauseState {
+    isPaused: boolean;
+    pausedAt: number | null;
+    pauseReason: 'user_abort' | 'error' | 'explicit' | null;
+}
+/**
+ * Pause a session, preventing automatic continuations.
+ * Called when MessageAbortedError is detected (user pressed ESC).
+ */
+export declare function pauseSession(sessionId: string, reason?: SessionPauseState['pauseReason']): void;
+/**
+ * Check if a session is currently paused.
+ */
+export declare function isSessionPaused(sessionId: string): boolean;
+/**
+ * Get the pause state for a session.
+ */
+export declare function getSessionPauseState(sessionId: string): SessionPauseState | undefined;
+/**
+ * Resume a session, allowing automatic continuations.
+ * Called when user sends a new prompt or explicitly resumes.
+ */
+export declare function resumeSession(sessionId: string): void;
+/**
+ * Clear session state when session is deleted.
+ */
+export declare function clearSessionPauseState(sessionId: string): void;
+export {};

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

@@ -1,5 +1,6 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 import type { BackgroundTaskConfig } from "../config";
+import type { ModelResolutionService } from "./model-resolution-service";
 export interface BackgroundTask {
     id: string;
     status: "running" | "completed" | "failed" | "cancelled";
@@ -11,12 +12,17 @@ export interface BackgroundTask {
     startedAt: number;
     completedAt?: number;
 }
+export interface ModelConfig {
+    providerID: string;
+    modelID: string;
+}
 export interface BackgroundManager {
-    createTask: (parentSessionID: string, description: string, prompt: string, agent: string) => Promise<BackgroundTask>;
+    createTask: (parentSessionID: string, description: string, prompt: string, agent: string, model?: ModelConfig) => Promise<BackgroundTask>;
     getTask: (taskId: string) => BackgroundTask | undefined;
     getTasksByParentSession: (sessionID: string) => BackgroundTask[];
     cancelTask: (taskId: string) => boolean;
     cancelAllTasks: (parentSessionID?: string) => number;
     waitForTask: (taskId: string, timeoutMs?: number) => Promise<BackgroundTask>;
+    getParentSessionModel: (parentSessionID: string) => Promise<ModelConfig | undefined>;
 }
-export declare function createBackgroundManager(ctx: PluginInput, config?: BackgroundTaskConfig): BackgroundManager;
+export declare function createBackgroundManager(ctx: PluginInput, config?: BackgroundTaskConfig, modelService?: ModelResolutionService): BackgroundManager;

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

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

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

@@ -0,0 +1,38 @@
+/**
+ * Model Resolution Service
+ *
+ * Centralized model resolution for agent invocations.
+ * Connects ModelResolver (config-based tier mapping) to runtime tool calls.
+ *
+ * Priority chain:
+ * 1. Per-agent config model override
+ * 2. Per-agent config tier → tierDefaults
+ * 3. Agent definition tier → tierDefaults
+ * 4. Fallback to sonnet tier
+ * 5. If all else fails, use parent session model
+ */
+import { type AgentModelConfig, type ModelMappingConfig } from "../config/model-resolver";
+export interface ModelConfig {
+    providerID: string;
+    modelID: string;
+}
+export interface ModelResolutionService {
+    /**
+     * Resolve model for an agent based on tier configuration
+     * @param agentName - Name of the agent (canonical or alias)
+     * @param fallbackModel - Parent session model to use if resolution fails
+     * @returns Resolved ModelConfig or undefined if should use fallback
+     */
+    resolveModelForAgent(agentName: string, fallbackModel?: ModelConfig): ModelConfig | undefined;
+    /**
+     * Check if tier mapping is configured (tierDefaults has provider/model format)
+     */
+    isTierMappingConfigured(): boolean;
+}
+/**
+ * Create a ModelResolutionService instance
+ *
+ * @param modelMappingConfig - Config from omco.json model_mapping section
+ * @param agentOverrides - Per-agent config overrides from omco.json agents section
+ */
+export declare function createModelResolutionService(modelMappingConfig?: ModelMappingConfig, agentOverrides?: Record<string, AgentModelConfig>): ModelResolutionService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-claudecode-opencode",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "description": "OpenCode port of oh-my-claudecode - Multi-agent orchestration plugin (omco)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -28,6 +28,9 @@
     "prepublishOnly": "bun run clean && bun run build",
     "typecheck": "tsc --noEmit",
     "test": "bun test",
+    "test:e2e": "vitest run --config tests/e2e/vitest.config.ts",
+    "test:e2e:server": "vitest run --config tests/e2e/vitest.config.ts --testNamePattern 'Server'",
+    "test:all": "bun test && vitest run --config tests/e2e/vitest.config.ts",
     "lint": "eslint src --ext .ts"
   },
   "keywords": [