oh-my-claudecode-opencode 0.6.2 → 0.6.3

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;
@@ -21672,6 +21672,7 @@ function generateTaskId() {
 function createBackgroundManager(ctx, config2) {
   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,7 @@ function createBackgroundManager(ctx, config2) {
     };
     tasks.set(taskId, task);
     log(`Background task created`, { taskId, description, agent });
+    const resolvedModel = model || await getParentSessionModel(parentSessionID);
     (async () => {
       try {
         const sessionResp = await ctx.client.session.create({
@@ -21717,19 +21746,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 +21808,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 +21827,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 +21862,8 @@ ${prompt}` : prompt;
     getTasksByParentSession,
     cancelTask,
     cancelAllTasks,
-    waitForTask
+    waitForTask,
+    getParentSessionModel
   };
 }
 
@@ -34237,8 +34292,9 @@ Prompts MUST be in English. Use \`background_output\` for async results.`,
 ---
 
 ${prompt}`;
+      const parentModel = await manager.getParentSessionModel(context.sessionID);
       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, parentModel);
         return JSON.stringify({
           task_id: task.id,
           session_id: task.sessionID,
@@ -34257,19 +34313,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 (parentModel) {
+          promptBody.model = parentModel;
+          log(`Using parent model for sync agent call`, { subagent_type, ...parentModel });
+        }
+        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 +34361,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`);
   }
 }
 
@@ -38229,6 +38306,19 @@ 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);
@@ -38335,6 +38425,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

@@ -11,12 +11,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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-claudecode-opencode",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "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": [