oh-my-opencode-slim 0.8.0 → 0.8.1

package/dist/cli/index.js

@@ -80,11 +80,11 @@ function pickSupportChutesModel(models, primaryModel) {
 }
 // src/cli/config-io.ts
 import {
-  copyFileSync,
-  existsSync as existsSync2,
+  copyFileSync as copyFileSync2,
+  existsSync as existsSync3,
   readFileSync,
   renameSync,
-  statSync,
+  statSync as statSync2,
   writeFileSync
 } from "fs";
 
@@ -13729,7 +13729,7 @@ var BackgroundTaskConfigSchema = exports_external.object({
 });
 var FailoverConfigSchema = exports_external.object({
   enabled: exports_external.boolean().default(true),
-  timeoutMs: exports_external.number().min(1000).max(120000).default(15000),
+  timeoutMs: exports_external.number().min(0).default(15000),
   chains: FallbackChainsSchema.default({})
 });
 var PluginConfigSchema = exports_external.object({
@@ -13756,6 +13756,67 @@ var DEFAULT_AGENT_MCPS = {
 
 // src/cli/skills.ts
 import { spawnSync } from "child_process";
+
+// src/cli/custom-skills.ts
+import {
+  copyFileSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readdirSync,
+  statSync
+} from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname, join as join2 } from "path";
+import { fileURLToPath } from "url";
+var CUSTOM_SKILLS = [
+  {
+    name: "cartography",
+    description: "Repository understanding and hierarchical codemap generation",
+    allowedAgents: ["orchestrator", "explorer"],
+    sourcePath: "src/skills/cartography"
+  }
+];
+function getCustomSkillsDir() {
+  return join2(homedir2(), ".config", "opencode", "skills");
+}
+function copyDirRecursive(src, dest) {
+  if (!existsSync2(dest)) {
+    mkdirSync2(dest, { recursive: true });
+  }
+  const entries = readdirSync(src);
+  for (const entry of entries) {
+    const srcPath = join2(src, entry);
+    const destPath = join2(dest, entry);
+    const stat = statSync(srcPath);
+    if (stat.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      const destDir = dirname(destPath);
+      if (!existsSync2(destDir)) {
+        mkdirSync2(destDir, { recursive: true });
+      }
+      copyFileSync(srcPath, destPath);
+    }
+  }
+}
+function installCustomSkill(skill) {
+  try {
+    const packageRoot = fileURLToPath(new URL("../..", import.meta.url));
+    const sourcePath = join2(packageRoot, skill.sourcePath);
+    const targetPath = join2(getCustomSkillsDir(), skill.name);
+    if (!existsSync2(sourcePath)) {
+      console.error(`Custom skill source not found: ${sourcePath}`);
+      return false;
+    }
+    copyDirRecursive(sourcePath, targetPath);
+    return true;
+  } catch (error48) {
+    console.error(`Failed to install custom skill: ${skill.name}`, error48);
+    return false;
+  }
+}
+
+// src/cli/skills.ts
 var RECOMMENDED_SKILLS = [
   {
     name: "simplify",
@@ -13863,7 +13924,7 @@ var MODEL_MAPPINGS = {
   },
   antigravity: {
     orchestrator: { model: "google/antigravity-gemini-3-flash" },
-    oracle: { model: "google/antigravity-gemini-3-pro" },
+    oracle: { model: "google/antigravity-gemini-3.1-pro" },
     librarian: {
       model: "google/antigravity-gemini-3-flash",
       variant: "low"
@@ -14203,9 +14264,9 @@ function stripJsonComments(json2) {
 }
 function parseConfigFile(path) {
   try {
-    if (!existsSync2(path))
+    if (!existsSync3(path))
       return { config: null };
-    const stat = statSync(path);
+    const stat = statSync2(path);
     if (stat.size === 0)
       return { config: null };
     const content = readFileSync(path, "utf-8");
@@ -14234,8 +14295,8 @@ function writeConfig(configPath, config2) {
   const bakPath = `${configPath}.bak`;
   const content = `${JSON.stringify(config2, null, 2)}
 `;
-  if (existsSync2(configPath)) {
-    copyFileSync(configPath, bakPath);
+  if (existsSync3(configPath)) {
+    copyFileSync2(configPath, bakPath);
   }
   writeFileSync(tmpPath, content);
   renameSync(tmpPath, configPath);
@@ -14284,8 +14345,8 @@ function writeLiteConfig(installConfig) {
     const bakPath = `${configPath}.bak`;
     const content = `${JSON.stringify(config2, null, 2)}
 `;
-    if (existsSync2(configPath)) {
-      copyFileSync(configPath, bakPath);
+    if (existsSync3(configPath)) {
+      copyFileSync2(configPath, bakPath);
     }
     writeFileSync(tmpPath, content);
     renameSync(tmpPath, configPath);
@@ -14368,8 +14429,8 @@ function addGoogleProvider() {
     const providers = config2.provider ?? {};
     providers.google = {
       models: {
-        "antigravity-gemini-3-pro": {
-          name: "Gemini 3 Pro (Antigravity)",
+        "antigravity-gemini-3.1-pro": {
+          name: "Gemini 3.1 Pro (Antigravity)",
           limit: { context: 1048576, output: 65535 },
           modalities: { input: ["text", "image", "pdf"], output: ["text"] },
           variants: {
@@ -14426,8 +14487,8 @@ function addGoogleProvider() {
           limit: { context: 1048576, output: 65536 },
           modalities: { input: ["text", "image", "pdf"], output: ["text"] }
         },
-        "gemini-3-pro-preview": {
-          name: "Gemini 3 Pro Preview (Gemini CLI)",
+        "gemini-3.1-pro-preview": {
+          name: "Gemini 3.1 Pro Preview (Gemini CLI)",
           limit: { context: 1048576, output: 65535 },
           modalities: { input: ["text", "image", "pdf"], output: ["text"] }
         }
@@ -15751,7 +15812,7 @@ async function fetchExternalModelSignals(options) {
   return { signals: aggregate, warnings };
 }
 // src/cli/system.ts
-import { statSync as statSync2 } from "fs";
+import { statSync as statSync3 } from "fs";
 var cachedOpenCodePath = null;
 function getOpenCodePaths() {
   const home = process.env.HOME || process.env.USERPROFILE || "";
@@ -15793,7 +15854,7 @@ function resolveOpenCodePath() {
     if (opencodePath === "opencode")
       continue;
     try {
-      const stat = statSync2(opencodePath);
+      const stat = statSync3(opencodePath);
       if (stat.isFile()) {
         cachedOpenCodePath = opencodePath;
         return opencodePath;
@@ -16023,65 +16084,6 @@ function pickSupportOpenCodeModel(models, primaryModel) {
   }, primaryModel);
   return support;
 }
-// src/cli/custom-skills.ts
-import {
-  copyFileSync as copyFileSync2,
-  existsSync as existsSync3,
-  mkdirSync as mkdirSync2,
-  readdirSync,
-  statSync as statSync3
-} from "fs";
-import { homedir as homedir2 } from "os";
-import { dirname, join as join3 } from "path";
-import { fileURLToPath } from "url";
-var CUSTOM_SKILLS = [
-  {
-    name: "cartography",
-    description: "Repository understanding and hierarchical codemap generation",
-    allowedAgents: ["orchestrator"],
-    sourcePath: "src/skills/cartography"
-  }
-];
-function getCustomSkillsDir() {
-  return join3(homedir2(), ".config", "opencode", "skills");
-}
-function copyDirRecursive(src, dest) {
-  if (!existsSync3(dest)) {
-    mkdirSync2(dest, { recursive: true });
-  }
-  const entries = readdirSync(src);
-  for (const entry of entries) {
-    const srcPath = join3(src, entry);
-    const destPath = join3(dest, entry);
-    const stat = statSync3(srcPath);
-    if (stat.isDirectory()) {
-      copyDirRecursive(srcPath, destPath);
-    } else {
-      const destDir = dirname(destPath);
-      if (!existsSync3(destDir)) {
-        mkdirSync2(destDir, { recursive: true });
-      }
-      copyFileSync2(srcPath, destPath);
-    }
-  }
-}
-function installCustomSkill(skill) {
-  try {
-    const packageRoot = fileURLToPath(new URL("../..", import.meta.url));
-    const sourcePath = join3(packageRoot, skill.sourcePath);
-    const targetPath = join3(getCustomSkillsDir(), skill.name);
-    if (!existsSync3(sourcePath)) {
-      console.error(`Custom skill source not found: ${sourcePath}`);
-      return false;
-    }
-    copyDirRecursive(sourcePath, targetPath);
-    return true;
-  } catch (error48) {
-    console.error(`Failed to install custom skill: ${skill.name}`, error48);
-    return false;
-  }
-}
-
 // src/cli/install.ts
 var GREEN = "\x1B[32m";
 var BLUE = "\x1B[34m";
@@ -16430,8 +16432,8 @@ async function runManualSetupMode(rl, detected, modelsOnly = false) {
   }
   if (antigravity === "yes") {
     availableModels.push({
-      model: "google/antigravity-gemini-3-pro",
-      name: "Gemini 3 Pro"
+      model: "google/antigravity-gemini-3.1-pro",
+      name: "Gemini 3.1 Pro"
     });
     availableModels.push({
       model: "google/antigravity-gemini-3-flash",

package/dist/cli/providers.d.ts

@@ -130,7 +130,7 @@ export declare const MODEL_MAPPINGS: {
             readonly model: "google/antigravity-gemini-3-flash";
         };
         readonly oracle: {
-            readonly model: "google/antigravity-gemini-3-pro";
+            readonly model: "google/antigravity-gemini-3.1-pro";
         };
         readonly librarian: {
             readonly model: "google/antigravity-gemini-3-flash";

package/dist/cli/skills.d.ts

@@ -15,11 +15,28 @@ export interface RecommendedSkill {
     /** Optional commands to run after the skill is added */
     postInstallCommands?: string[];
 }
+/**
+ * A skill that is managed externally (e.g. user-installed) and needs
+ * permission grants but is NOT installed by this plugin's CLI.
+ */
+export interface PermissionOnlySkill {
+    /** Skill name — must match the name OpenCode uses for permission checks */
+    name: string;
+    /** List of agents that should auto-allow this skill */
+    allowedAgents: string[];
+    /** Human-readable description (for documentation only) */
+    description: string;
+}
 /**
  * List of recommended skills.
  * Add new skills here to include them in the installation flow.
  */
 export declare const RECOMMENDED_SKILLS: RecommendedSkill[];
+/**
+ * Skills managed externally (not installed by this plugin's CLI).
+ * Entries here only affect agent permission grants — nothing is installed.
+ */
+export declare const PERMISSION_ONLY_SKILLS: PermissionOnlySkill[];
 /**
  * Install a skill using `npx skills add`.
  * @param skill - The skill to install

package/dist/hooks/autopilot/index.d.ts

@@ -0,0 +1,43 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { PluginConfig } from '../../config';
+declare const AUTOPILOT_CONTINUE_PROMPT = "[AUTOPILOT] Continue executing work in this same session now. Do not acknowledge autopilot, do not ask for confirmation, and do not stop after a status message. Perform the next concrete action immediately (run a tool/command, edit files, or advance the active todo). Only stop when all todos are completed/cancelled or the user explicitly disables autopilot.";
+interface MessagePart {
+    type: string;
+    text?: string;
+}
+interface TodoEntry {
+    status?: string;
+}
+type AutopilotCommand = 'enable' | 'disable' | 'status' | null;
+declare function parseAutopilotCommand(text: string, keyword: string, disableKeyword: string): AutopilotCommand;
+declare function extractTodoList(data: unknown): TodoEntry[];
+declare function isActiveTodo(todo: TodoEntry): boolean;
+export declare function createAutopilotHook(ctx: PluginInput, config: PluginConfig): {
+    'chat.message': (input: {
+        sessionID: string;
+        agent?: string;
+        messageID?: string;
+    }, output: {
+        parts: MessagePart[];
+    }) => Promise<void>;
+    event: (input: {
+        event: {
+            type: string;
+            properties?: {
+                sessionID?: string;
+                status?: {
+                    type?: string;
+                };
+                info?: {
+                    id?: string;
+                    role?: string;
+                    sessionID?: string;
+                    time?: {
+                        completed?: number;
+                    };
+                };
+            };
+        };
+    }) => Promise<void>;
+};
+export { AUTOPILOT_CONTINUE_PROMPT, extractTodoList, isActiveTodo, parseAutopilotCommand, };

package/dist/hooks/delegate-task-retry/guidance.d.ts

@@ -0,0 +1,2 @@
+import { type DetectedError } from './patterns';
+export declare function buildRetryGuidance(errorInfo: DetectedError): string;

package/dist/hooks/delegate-task-retry/hook.d.ts

@@ -0,0 +1,8 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+export declare function createDelegateTaskRetryHook(_ctx: PluginInput): {
+    'tool.execute.after': (input: {
+        tool: string;
+    }, output: {
+        output: unknown;
+    }) => Promise<void>;
+};

package/dist/hooks/delegate-task-retry/index.d.ts

@@ -0,0 +1,4 @@
+export type { DelegateTaskErrorPattern, DetectedError } from './patterns';
+export { DELEGATE_TASK_ERROR_PATTERNS, detectDelegateTaskError } from './patterns';
+export { buildRetryGuidance } from './guidance';
+export { createDelegateTaskRetryHook } from './hook';

package/dist/hooks/delegate-task-retry/patterns.d.ts

@@ -0,0 +1,11 @@
+export interface DelegateTaskErrorPattern {
+    pattern: string;
+    errorType: string;
+    fixHint: string;
+}
+export declare const DELEGATE_TASK_ERROR_PATTERNS: DelegateTaskErrorPattern[];
+export interface DetectedError {
+    errorType: string;
+    originalOutput: string;
+}
+export declare function detectDelegateTaskError(output: string): DetectedError | null;

package/dist/hooks/index.d.ts

@@ -1,4 +1,6 @@
 export type { AutoUpdateCheckerOptions } from './auto-update-checker';
 export { createAutoUpdateCheckerHook } from './auto-update-checker';
+export { createDelegateTaskRetryHook } from './delegate-task-retry';
+export { createJsonErrorRecoveryHook } from './json-error-recovery';
 export { createPhaseReminderHook } from './phase-reminder';
 export { createPostReadNudgeHook } from './post-read-nudge';

package/dist/hooks/json-error-recovery/hook.d.ts

@@ -0,0 +1,18 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+export declare const JSON_ERROR_TOOL_EXCLUDE_LIST: readonly ["bash", "read", "glob", "grep", "webfetch", "grep_app_searchgithub", "websearch_web_search_exa"];
+export declare const JSON_ERROR_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp];
+export declare const JSON_ERROR_REMINDER = "\n[JSON PARSE ERROR - IMMEDIATE ACTION REQUIRED]\n\nYou sent invalid JSON arguments. The system could not parse your tool call.\nSTOP and do this NOW:\n\n1. LOOK at the error message above to see what was expected vs what you sent.\n2. CORRECT your JSON syntax (missing braces, unescaped quotes, trailing commas, etc).\n3. RETRY the tool call with valid JSON.\n\nDO NOT repeat the exact same invalid call.\n";
+interface ToolExecuteAfterInput {
+    tool: string;
+    sessionID: string;
+    callID: string;
+}
+interface ToolExecuteAfterOutput {
+    title: string;
+    output: unknown;
+    metadata: unknown;
+}
+export declare function createJsonErrorRecoveryHook(_ctx: PluginInput): {
+    'tool.execute.after': (input: ToolExecuteAfterInput, output: ToolExecuteAfterOutput) => Promise<void>;
+};
+export {};

package/dist/hooks/json-error-recovery/index.d.ts

@@ -0,0 +1 @@
+export { createJsonErrorRecoveryHook, JSON_ERROR_PATTERNS, JSON_ERROR_REMINDER, JSON_ERROR_TOOL_EXCLUDE_LIST, } from './hook';

package/dist/index.js

@@ -3277,6 +3277,16 @@ var require_main = __commonJS((exports) => {
   exports.createMessageConnection = createMessageConnection;
 });
 
+// src/cli/custom-skills.ts
+var CUSTOM_SKILLS = [
+  {
+    name: "cartography",
+    description: "Repository understanding and hierarchical codemap generation",
+    allowedAgents: ["orchestrator", "explorer"],
+    sourcePath: "src/skills/cartography"
+  }
+];
+
 // src/cli/skills.ts
 var RECOMMENDED_SKILLS = [
   {
@@ -3298,6 +3308,13 @@ var RECOMMENDED_SKILLS = [
     ]
   }
 ];
+var PERMISSION_ONLY_SKILLS = [
+  {
+    name: "requesting-code-review",
+    allowedAgents: ["oracle"],
+    description: "Code review template for reviewer subagents in multi-step workflows"
+  }
+];
 function getSkillPermissionsForAgent(agentName, skillList) {
   const permissions = {
     "*": agentName === "orchestrator" ? "allow" : "deny"
@@ -3321,6 +3338,18 @@ function getSkillPermissionsForAgent(agentName, skillList) {
       permissions[skill.skillName] = "allow";
     }
   }
+  for (const skill of CUSTOM_SKILLS) {
+    const isAllowed = skill.allowedAgents.includes("*") || skill.allowedAgents.includes(agentName);
+    if (isAllowed) {
+      permissions[skill.name] = "allow";
+    }
+  }
+  for (const skill of PERMISSION_ONLY_SKILLS) {
+    const isAllowed = skill.allowedAgents.includes("*") || skill.allowedAgents.includes(agentName);
+    if (isAllowed) {
+      permissions[skill.name] = "allow";
+    }
+  }
   return permissions;
 }
 
@@ -3340,8 +3369,8 @@ var ORCHESTRATOR_NAME = "orchestrator";
 var ALL_AGENT_NAMES = [ORCHESTRATOR_NAME, ...SUBAGENT_NAMES];
 var SUBAGENT_DELEGATION_RULES = {
   orchestrator: SUBAGENT_NAMES,
-  fixer: ["explorer"],
-  designer: ["explorer"],
+  fixer: [],
+  designer: [],
   explorer: [],
   librarian: [],
   oracle: []
@@ -17010,7 +17039,7 @@ var BackgroundTaskConfigSchema = exports_external.object({
 });
 var FailoverConfigSchema = exports_external.object({
   enabled: exports_external.boolean().default(true),
-  timeoutMs: exports_external.number().min(1000).max(120000).default(15000),
+  timeoutMs: exports_external.number().min(0).default(15000),
   chains: FallbackChainsSchema.default({})
 });
 var PluginConfigSchema = exports_external.object({
@@ -17280,9 +17309,10 @@ var FIXER_PROMPT = `You are Fixer - a fast, focused implementation specialist.
 
 **Constraints**:
 - NO external research (no websearch, context7, grep_app)
-- NO delegation (no background_task)
+- NO delegation (no background_task, no spawning subagents)
 - No multi-step research/planning; minimal execution sequence ok
-- If context is insufficient, read the files listed; only ask for missing inputs you cannot retrieve
+- If context is insufficient: use grep/glob/lsp_diagnostics directly \u2014 do not delegate
+- Only ask for missing inputs you truly cannot retrieve yourself
 
 **Output Format**:
 <summary>
@@ -17504,6 +17534,10 @@ Balance: respect dependencies, avoid parallelizing what must be sequential.
 - Confirm specialists completed successfully
 - Verify solution meets requirements
 
+## Agent Role Mapping
+When a workflow calls for an **implementer** subagent: dispatch \`@fixer\`. Fixer has enforced constraints (no research, no delegation, structured output) that match the implementer role exactly.
+When a workflow calls for a **reviewer** subagent: dispatch \`@oracle\`. Oracle has the depth for architectural review and access to code review skills.
+
 </Workflow>
 
 <Communication>
@@ -18094,6 +18128,10 @@ class BackgroundTaskManager {
     return chain;
   }
   async promptWithTimeout(args, timeoutMs) {
+    if (timeoutMs <= 0) {
+      await this.client.session.prompt(args);
+      return;
+    }
     await Promise.race([
       this.client.session.prompt(args),
       new Promise((_, reject) => {
@@ -18143,8 +18181,8 @@ class BackgroundTaskManager {
         tools: toolPermissions,
         parts: [{ type: "text", text: task.prompt }]
       });
-      const timeoutMs = this.config?.fallback?.timeoutMs ?? FALLBACK_FAILOVER_TIMEOUT_MS;
       const fallbackEnabled = this.config?.fallback?.enabled ?? true;
+      const timeoutMs = fallbackEnabled ? this.config?.fallback?.timeoutMs ?? FALLBACK_FAILOVER_TIMEOUT_MS : 0;
       const chain = fallbackEnabled ? this.resolveFallbackChain(task.agent) : [];
       const attemptModels = chain.length > 0 ? chain : [undefined];
       const errors3 = [];
@@ -18933,10 +18971,169 @@ function showToast(ctx, title, message, variant = "info", duration3 = 3000) {
     body: { title, message, variant, duration: duration3 }
   }).catch(() => {});
 }
+// src/hooks/delegate-task-retry/patterns.ts
+var DELEGATE_TASK_ERROR_PATTERNS = [
+  {
+    pattern: "run_in_background",
+    errorType: "missing_run_in_background",
+    fixHint: "Add run_in_background=false (delegation) or run_in_background=true (parallel exploration)."
+  },
+  {
+    pattern: "load_skills",
+    errorType: "missing_load_skills",
+    fixHint: "Add load_skills=[] (empty array when no skill is needed)."
+  },
+  {
+    pattern: "category OR subagent_type",
+    errorType: "mutual_exclusion",
+    fixHint: 'Provide only one: category (e.g., "unspecified-low") OR subagent_type (e.g., "explorer").'
+  },
+  {
+    pattern: "Must provide either category or subagent_type",
+    errorType: "missing_category_or_agent",
+    fixHint: 'Add either category="unspecified-low" or subagent_type="explorer".'
+  },
+  {
+    pattern: "Unknown category",
+    errorType: "unknown_category",
+    fixHint: "Use a valid category listed in the error output."
+  },
+  {
+    pattern: "Unknown agent",
+    errorType: "unknown_agent",
+    fixHint: "Use a valid agent name from the available list."
+  },
+  {
+    pattern: "Skills not found",
+    errorType: "unknown_skills",
+    fixHint: "Use valid skill names listed in the error output."
+  },
+  {
+    pattern: "is not allowed. Allowed agents:",
+    errorType: "background_agent_not_allowed",
+    fixHint: "Use one of the allowed agents shown in the error or delegate from a parent agent that can call this subagent."
+  }
+];
+function detectDelegateTaskError(output) {
+  if (!output || typeof output !== "string")
+    return null;
+  const hasErrorSignal = output.includes("[ERROR]") || output.includes("Invalid arguments") || output.includes("is not allowed. Allowed agents:");
+  if (!hasErrorSignal)
+    return null;
+  for (const pattern of DELEGATE_TASK_ERROR_PATTERNS) {
+    if (output.includes(pattern.pattern)) {
+      return {
+        errorType: pattern.errorType,
+        originalOutput: output
+      };
+    }
+  }
+  return null;
+}
+// src/hooks/delegate-task-retry/guidance.ts
+function extractAvailableList(output) {
+  const match = output.match(/Allowed agents:\s*(.+)$/m);
+  if (match)
+    return match[1].trim();
+  const available = output.match(/Available[^:]*:\s*(.+)$/m);
+  if (available)
+    return available[1].trim();
+  return null;
+}
+function buildRetryGuidance(errorInfo) {
+  const pattern = DELEGATE_TASK_ERROR_PATTERNS.find((p) => p.errorType === errorInfo.errorType);
+  if (!pattern) {
+    return `
+[delegate-task retry] Fix parameters and retry with corrected arguments.`;
+  }
+  const available = extractAvailableList(errorInfo.originalOutput);
+  const lines = [
+    "",
+    "[delegate-task retry suggestion]",
+    `Error type: ${errorInfo.errorType}`,
+    `Fix: ${pattern.fixHint}`
+  ];
+  if (available) {
+    lines.push(`Available: ${available}`);
+  }
+  lines.push("Retry now with corrected parameters. Example:", 'task(description="...", prompt="...", category="unspecified-low", run_in_background=false, load_skills=[])');
+  return lines.join(`
+`);
+}
+// src/hooks/delegate-task-retry/hook.ts
+function createDelegateTaskRetryHook(_ctx) {
+  return {
+    "tool.execute.after": async (input, output) => {
+      const toolName = input.tool.toLowerCase();
+      const isDelegateTool = toolName === "task" || toolName === "background_task";
+      if (!isDelegateTool)
+        return;
+      if (typeof output.output !== "string")
+        return;
+      const detected = detectDelegateTaskError(output.output);
+      if (!detected)
+        return;
+      output.output += `
+${buildRetryGuidance(detected)}`;
+    }
+  };
+}
+// src/hooks/json-error-recovery/hook.ts
+var JSON_ERROR_TOOL_EXCLUDE_LIST = [
+  "bash",
+  "read",
+  "glob",
+  "grep",
+  "webfetch",
+  "grep_app_searchgithub",
+  "websearch_web_search_exa"
+];
+var JSON_ERROR_PATTERNS = [
+  /json parse error/i,
+  /failed to parse json/i,
+  /invalid json/i,
+  /malformed json/i,
+  /unexpected end of json input/i,
+  /syntaxerror:\s*unexpected token.*json/i,
+  /json[^\n]*expected '\}'/i,
+  /json[^\n]*unexpected eof/i
+];
+var JSON_ERROR_REMINDER_MARKER = "[JSON PARSE ERROR - IMMEDIATE ACTION REQUIRED]";
+var JSON_ERROR_EXCLUDED_TOOLS = new Set(JSON_ERROR_TOOL_EXCLUDE_LIST);
+var JSON_ERROR_REMINDER = `
+[JSON PARSE ERROR - IMMEDIATE ACTION REQUIRED]
+
+You sent invalid JSON arguments. The system could not parse your tool call.
+STOP and do this NOW:
+
+1. LOOK at the error message above to see what was expected vs what you sent.
+2. CORRECT your JSON syntax (missing braces, unescaped quotes, trailing commas, etc).
+3. RETRY the tool call with valid JSON.
+
+DO NOT repeat the exact same invalid call.
+`;
+function createJsonErrorRecoveryHook(_ctx) {
+  return {
+    "tool.execute.after": async (input, output) => {
+      if (JSON_ERROR_EXCLUDED_TOOLS.has(input.tool.toLowerCase()))
+        return;
+      if (typeof output.output !== "string")
+        return;
+      if (output.output.includes(JSON_ERROR_REMINDER_MARKER))
+        return;
+      const outputText = output.output;
+      const hasJsonError = JSON_ERROR_PATTERNS.some((pattern) => pattern.test(outputText));
+      if (hasJsonError) {
+        output.output += `
+${JSON_ERROR_REMINDER}`;
+      }
+    }
+  };
+}
 // src/hooks/phase-reminder/index.ts
-var PHASE_REMINDER = `<reminder>\u26A0\uFE0F MANDATORY: Understand\u2192DELEGATE(! based on each agent rules)\u2192Split-and-Parallelize(?)\u2192Plan\u2192Execute\u2192Verify
-Available Specialist: @oracle @librarian @explorer @designer @fixer
-</reminder>`;
+var PHASE_REMINDER = `<reminder>Recall Workflow Rules:
+Understand \u2192 find the best path (delegate based on rules and parallelize independent work) \u2192 execute \u2192 verify.
+If delegating, launch the specialist in the same turn you mention it.</reminder>`;
 function createPhaseReminderHook() {
   return {
     "experimental.chat.messages.transform": async (_input, output) => {
@@ -18976,7 +19173,7 @@ ${originalText}`;
 var NUDGE = `
 
 ---
-Reminder to follow the workflow instructions, consider delegation to specialist(s)`;
+Workflow Reminder: delegate based on rules; If mentioning a specialist, launch it in this same turn.`;
 function createPostReadNudgeHook() {
   return {
     "tool.execute.after": async (input, output) => {
@@ -33242,6 +33439,8 @@ var OhMyOpenCodeLite = async (ctx) => {
   });
   const phaseReminderHook = createPhaseReminderHook();
   const postReadNudgeHook = createPostReadNudgeHook();
+  const delegateTaskRetryHook = createDelegateTaskRetryHook(ctx);
+  const jsonErrorRecoveryHook = createJsonErrorRecoveryHook(ctx);
   return {
     name: "oh-my-opencode-slim",
     agent: agents,
@@ -33301,7 +33500,11 @@ var OhMyOpenCodeLite = async (ctx) => {
       await tmuxSessionManager.onSessionDeleted(input.event);
     },
     "experimental.chat.messages.transform": phaseReminderHook["experimental.chat.messages.transform"],
-    "tool.execute.after": postReadNudgeHook["tool.execute.after"]
+    "tool.execute.after": async (input, output) => {
+      await delegateTaskRetryHook["tool.execute.after"](input, output);
+      await jsonErrorRecoveryHook["tool.execute.after"](input, output);
+      await postReadNudgeHook["tool.execute.after"](input, output);
+    }
   };
 };
 var src_default = OhMyOpenCodeLite;

package/package.json

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

package/dist/tools/quota/api.d.ts

@@ -1,5 +0,0 @@
-import type { Account, AccountQuotaResult, AccountsConfig } from './types';
-export declare const CONFIG_PATHS: string[];
-export declare function loadAccountsConfig(): AccountsConfig | null;
-export declare function fetchAccountQuota(account: Account): Promise<AccountQuotaResult>;
-export declare function fetchAllQuotas(accounts: Account[]): Promise<AccountQuotaResult[]>;

package/dist/tools/quota/command.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tools/quota/index.d.ts

@@ -1,21 +0,0 @@
-/**
- * Compact quota display tool - groups models by quota family
- *
- * Output format:
- * ```
- * tornikevault
- *   Claude   [░░░░░░░░░░]   0%  3h23m
- *   G-Flash  [██████████] 100%  4h59m
- *   G-Pro    [██████████] 100%  4h59m
- *
- * tzedgin
- *   Claude   [░░░░░░░░░░]   0%  1h41m
- *   G-Flash  [██████████] 100%  4h59m
- *   G-Pro    [██████████] 100%  4h59m
- * ```
- */
-export declare const antigravity_quota: {
-    description: string;
-    args: {};
-    execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
-};

package/dist/tools/quota/types.d.ts

@@ -1,41 +0,0 @@
-export interface Account {
-    email: string;
-    refreshToken: string;
-    projectId?: string;
-    managedProjectId?: string;
-    rateLimitResetTimes: Record<string, number>;
-}
-export interface AccountsConfig {
-    accounts: Account[];
-    activeIndex: number;
-}
-export interface QuotaInfo {
-    remainingFraction?: number;
-    resetTime?: string;
-}
-export interface ModelInfo {
-    displayName?: string;
-    model?: string;
-    quotaInfo?: QuotaInfo;
-    recommended?: boolean;
-}
-export interface QuotaResponse {
-    models?: Record<string, ModelInfo>;
-}
-export interface TokenResponse {
-    access_token: string;
-}
-export interface LoadCodeAssistResponse {
-    cloudaicompanionProject?: unknown;
-}
-export interface ModelQuota {
-    name: string;
-    percent: number;
-    resetIn: string;
-}
-export interface AccountQuotaResult {
-    email: string;
-    success: boolean;
-    error?: string;
-    models: ModelQuota[];
-}