oh-my-opencode-slim 0.8.0 → 0.8.2

package/README.md

@@ -2,7 +2,7 @@
   <img src="img/team.png" alt="Pantheon agents" width="420">
   <p><i>Six divine beings emerged from the dawn of code, each an immortal master of their craft await your command to forge order from chaos and build what was once thought impossible.</i></p>
   <p><b>Open Multi Agent Suite</b> · Mix any models · Auto delegate tasks</p>
-  <p><a href="https://moltfounders.com/project/0f5874c7-9291-415b-9622-7509d96a2c73"><img src="https://moltfounders.com/badges/4.png" alt="MoltFounders" height="30"></a></p>
+  <p><a href="https://moltfounders.com/jobs/09d1c6e7-9e0e-4683-8d78-e2376aaa2333"><img src="https://moltfounders.com/badges/4.png" alt="MoltFounders" height="30"></a></p>
 </div>
 
 ---
@@ -259,6 +259,6 @@ MIT
 ---
 
 <!-- MoltFounders Banner -->
-<a href="https://moltfounders.com/project/0f5874c7-9291-415b-9622-7509d96a2c73">
+<a href="https://moltfounders.com/jobs/09d1c6e7-9e0e-4683-8d78-e2376aaa2333">
   <img src="img/moltfounders-banner.png" alt="MoltFounders - The Agent Co-Founder Network">
 </a>

package/dist/agents/orchestrator.d.ts

@@ -3,5 +3,13 @@ export interface AgentDefinition {
     name: string;
     description?: string;
     config: AgentConfig;
+    /** Priority-ordered model entries for runtime fallback resolution. */
+    _modelArray?: Array<{
+        id: string;
+        variant?: string;
+    }>;
 }
-export declare function createOrchestratorAgent(model: string, customPrompt?: string, customAppendPrompt?: string): AgentDefinition;
+export declare function createOrchestratorAgent(model?: string | Array<string | {
+    id: string;
+    variant?: string;
+}>, customPrompt?: string, customAppendPrompt?: string): AgentDefinition;

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";
 
@@ -13704,7 +13704,16 @@ var FallbackChainsSchema = exports_external.object({
   fixer: AgentModelChainSchema.optional()
 }).catchall(AgentModelChainSchema);
 var AgentOverrideConfigSchema = exports_external.object({
-  model: exports_external.string().optional(),
+  model: exports_external.union([
+    exports_external.string(),
+    exports_external.array(exports_external.union([
+      exports_external.string(),
+      exports_external.object({
+        id: exports_external.string(),
+        variant: exports_external.string().optional()
+      })
+    ]))
+  ]).optional(),
   temperature: exports_external.number().min(0).max(2).optional(),
   variant: exports_external.string().optional().catch(undefined),
   skills: exports_external.array(exports_external.string()).optional(),
@@ -13729,7 +13738,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 +13765,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 +13933,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 +14273,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 +14304,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 +14354,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 +14438,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 +14496,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 +15821,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 +15863,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 +16093,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 +16441,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/config/constants.d.ts

@@ -4,7 +4,7 @@ export declare const ORCHESTRATOR_NAME: "orchestrator";
 export declare const ALL_AGENT_NAMES: readonly ["orchestrator", "explorer", "librarian", "oracle", "designer", "fixer"];
 export type AgentName = (typeof ALL_AGENT_NAMES)[number];
 export declare const SUBAGENT_DELEGATION_RULES: Record<AgentName, readonly string[]>;
-export declare const DEFAULT_MODELS: Record<AgentName, string>;
+export declare const DEFAULT_MODELS: Record<AgentName, string | undefined>;
 export declare const POLL_INTERVAL_MS = 500;
 export declare const POLL_INTERVAL_SLOW_MS = 1000;
 export declare const POLL_INTERVAL_BACKGROUND_MS = 2000;

package/dist/config/loader.d.ts

@@ -17,11 +17,14 @@ export declare function loadPluginConfig(directory: string): PluginConfig;
 /**
  * Load custom prompt for an agent from the prompts directory.
  * Checks for {agent}.md (replaces default) and {agent}_append.md (appends to default).
+ * If preset is provided and safe for paths, it first checks {preset}/ subdirectory,
+ * then falls back to the root prompts directory.
  *
  * @param agentName - Name of the agent (e.g., "orchestrator", "explorer")
+ * @param preset - Optional preset name for preset-scoped prompt lookup
  * @returns Object with prompt and/or appendPrompt if files exist
  */
-export declare function loadAgentPrompt(agentName: string): {
+export declare function loadAgentPrompt(agentName: string, preset?: string): {
     prompt?: string;
     appendPrompt?: string;
 };

package/dist/config/schema.d.ts

@@ -50,7 +50,10 @@ export type ManualAgentPlan = z.infer<typeof ManualAgentPlanSchema>;
 export type ManualPlan = z.infer<typeof ManualPlanSchema>;
 export type FallbackAgentName = (typeof FALLBACK_AGENT_NAMES)[number];
 export declare const AgentOverrideConfigSchema: z.ZodObject<{
-    model: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        variant: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>]>>;
     temperature: z.ZodOptional<z.ZodNumber>;
     variant: z.ZodCatch<z.ZodOptional<z.ZodString>>;
     skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -77,8 +80,16 @@ export declare const TmuxConfigSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type TmuxConfig = z.infer<typeof TmuxConfigSchema>;
 export type AgentOverrideConfig = z.infer<typeof AgentOverrideConfigSchema>;
+/** Normalized model entry with optional per-model variant. */
+export type ModelEntry = {
+    id: string;
+    variant?: string;
+};
 export declare const PresetSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
-    model: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        variant: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>]>>;
     temperature: z.ZodOptional<z.ZodNumber>;
     variant: z.ZodCatch<z.ZodOptional<z.ZodString>>;
     skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -155,14 +166,20 @@ export declare const PluginConfigSchema: z.ZodObject<{
         }, z.core.$strip>;
     }, z.core.$strict>>;
     presets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
-        model: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            variant: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>>]>>;
         temperature: z.ZodOptional<z.ZodNumber>;
         variant: z.ZodCatch<z.ZodOptional<z.ZodString>>;
         skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
         mcps: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>>>;
     agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        model: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            variant: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>>]>>;
         temperature: z.ZodOptional<z.ZodNumber>;
         variant: z.ZodCatch<z.ZodOptional<z.ZodString>>;
         skills: z.ZodOptional<z.ZodArray<z.ZodString>>;

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/chat-headers.d.ts

@@ -0,0 +1,16 @@
+import type { PluginInput, ProviderContext } from '@opencode-ai/plugin';
+import type { Model, UserMessage } from '@opencode-ai/sdk';
+interface ChatHeadersInput {
+    sessionID: string;
+    model: Model;
+    provider: ProviderContext;
+    message: UserMessage;
+}
+interface ChatHeadersOutput {
+    headers: Record<string, string>;
+}
+export declare function __resetInternalMarkerCacheForTesting(): void;
+export declare function createChatHeadersHook(ctx: PluginInput): {
+    'chat.headers': (input: ChatHeadersInput, output: ChatHeadersOutput) => Promise<void>;
+};
+export {};

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 { buildRetryGuidance } from './guidance';
+export { createDelegateTaskRetryHook } from './hook';
+export type { DelegateTaskErrorPattern, DetectedError } from './patterns';
+export { DELEGATE_TASK_ERROR_PATTERNS, detectDelegateTaskError, } from './patterns';

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,7 @@
 export type { AutoUpdateCheckerOptions } from './auto-update-checker';
 export { createAutoUpdateCheckerHook } from './auto-update-checker';
+export { createChatHeadersHook } from './chat-headers';
+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/hooks/phase-reminder/index.d.ts

@@ -1,3 +1,4 @@
+export declare const PHASE_REMINDER = "<reminder>Recall Workflow Rules:\nUnderstand \u2192 find the best path (delegate based on rules and parallelize independent work) \u2192 execute \u2192 verify.\nIf delegating, launch the specialist in the same turn you mention it.</reminder>";
 interface MessageInfo {
     role: string;
     agent?: string;

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,14 +3369,14 @@ 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: []
 };
 var DEFAULT_MODELS = {
-  orchestrator: "kimi-for-coding/k2p5",
+  orchestrator: undefined,
   oracle: "openai/gpt-5.2-codex",
   librarian: "openai/gpt-5.1-codex-mini",
   explorer: "openai/gpt-5.1-codex-mini",
@@ -16985,7 +17014,16 @@ var FallbackChainsSchema = exports_external.object({
   fixer: AgentModelChainSchema.optional()
 }).catchall(AgentModelChainSchema);
 var AgentOverrideConfigSchema = exports_external.object({
-  model: exports_external.string().optional(),
+  model: exports_external.union([
+    exports_external.string(),
+    exports_external.array(exports_external.union([
+      exports_external.string(),
+      exports_external.object({
+        id: exports_external.string(),
+        variant: exports_external.string().optional()
+      })
+    ]))
+  ]).optional(),
   temperature: exports_external.number().min(0).max(2).optional(),
   variant: exports_external.string().optional().catch(undefined),
   skills: exports_external.array(exports_external.string()).optional(),
@@ -17010,7 +17048,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({
@@ -17109,25 +17147,27 @@ function loadPluginConfig(directory) {
   }
   return config2;
 }
-function loadAgentPrompt(agentName) {
+function loadAgentPrompt(agentName, preset) {
+  const presetDirName = preset && /^[a-zA-Z0-9_-]+$/.test(preset) ? preset : undefined;
   const promptsDir = path.join(getUserConfigDir(), "opencode", PROMPTS_DIR_NAME);
+  const promptSearchDirs = presetDirName ? [path.join(promptsDir, presetDirName), promptsDir] : [promptsDir];
   const result = {};
-  const promptPath = path.join(promptsDir, `${agentName}.md`);
-  if (fs.existsSync(promptPath)) {
-    try {
-      result.prompt = fs.readFileSync(promptPath, "utf-8");
-    } catch (error48) {
-      console.warn(`[oh-my-opencode-slim] Error reading prompt file ${promptPath}:`, error48 instanceof Error ? error48.message : String(error48));
-    }
-  }
-  const appendPromptPath = path.join(promptsDir, `${agentName}_append.md`);
-  if (fs.existsSync(appendPromptPath)) {
-    try {
-      result.appendPrompt = fs.readFileSync(appendPromptPath, "utf-8");
-    } catch (error48) {
-      console.warn(`[oh-my-opencode-slim] Error reading append prompt file ${appendPromptPath}:`, error48 instanceof Error ? error48.message : String(error48));
+  const readFirstPrompt = (fileName, errorPrefix) => {
+    for (const dir of promptSearchDirs) {
+      const promptPath = path.join(dir, fileName);
+      if (!fs.existsSync(promptPath)) {
+        continue;
+      }
+      try {
+        return fs.readFileSync(promptPath, "utf-8");
+      } catch (error48) {
+        console.warn(`[oh-my-opencode-slim] ${errorPrefix} ${promptPath}:`, error48 instanceof Error ? error48.message : String(error48));
+      }
     }
-  }
+    return;
+  };
+  result.prompt = readFirstPrompt(`${agentName}.md`, "Error reading prompt file");
+  result.appendPrompt = readFirstPrompt(`${agentName}_append.md`, "Error reading append prompt file");
   return result;
 }
 // src/config/utils.ts
@@ -17280,9 +17320,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 +17545,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>
@@ -17546,21 +17591,32 @@ function createOrchestratorAgent(model, customPrompt, customAppendPrompt) {
 
 ${customAppendPrompt}`;
   }
-  return {
+  const definition = {
     name: "orchestrator",
     description: "AI coding orchestrator that delegates tasks to specialist agents for optimal quality, speed, and cost",
     config: {
-      model,
       temperature: 0.1,
       prompt
     }
   };
+  if (Array.isArray(model)) {
+    definition._modelArray = model.map((m) => typeof m === "string" ? { id: m } : m);
+  } else if (typeof model === "string" && model) {
+    definition.config.model = model;
+  }
+  return definition;
 }
 
 // src/agents/index.ts
 function applyOverrides(agent, override) {
-  if (override.model)
-    agent.config.model = override.model;
+  if (override.model) {
+    if (Array.isArray(override.model)) {
+      agent._modelArray = override.model.map((m) => typeof m === "string" ? { id: m } : m);
+      agent.config.model = undefined;
+    } else {
+      agent.config.model = override.model;
+    }
+  }
   if (override.variant)
     agent.config.variant = override.variant;
   if (override.temperature !== undefined)
@@ -17591,12 +17647,20 @@ var SUBAGENT_FACTORIES = {
 function createAgents(config2) {
   const getModelForAgent = (name) => {
     if (name === "fixer" && !getAgentOverride(config2, "fixer")?.model) {
-      return getAgentOverride(config2, "librarian")?.model ?? DEFAULT_MODELS.librarian;
+      const librarianOverride = getAgentOverride(config2, "librarian")?.model;
+      let librarianModel;
+      if (Array.isArray(librarianOverride)) {
+        const first = librarianOverride[0];
+        librarianModel = typeof first === "string" ? first : first?.id;
+      } else {
+        librarianModel = librarianOverride;
+      }
+      return librarianModel ?? DEFAULT_MODELS.librarian;
     }
     return DEFAULT_MODELS[name];
   };
   const protoSubAgents = Object.entries(SUBAGENT_FACTORIES).map(([name, factory]) => {
-    const customPrompts = loadAgentPrompt(name);
+    const customPrompts = loadAgentPrompt(name, config2?.preset);
     return factory(getModelForAgent(name), customPrompts.prompt, customPrompts.appendPrompt);
   });
   const allSubAgents = protoSubAgents.map((agent) => {
@@ -17607,13 +17671,13 @@ function createAgents(config2) {
     applyDefaultPermissions(agent, override?.skills);
     return agent;
   });
-  const orchestratorModel = getAgentOverride(config2, "orchestrator")?.model ?? DEFAULT_MODELS.orchestrator;
-  const orchestratorPrompts = loadAgentPrompt("orchestrator");
+  const orchestratorOverride = getAgentOverride(config2, "orchestrator");
+  const orchestratorModel = orchestratorOverride?.model ?? DEFAULT_MODELS.orchestrator;
+  const orchestratorPrompts = loadAgentPrompt("orchestrator", config2?.preset);
   const orchestrator = createOrchestratorAgent(orchestratorModel, orchestratorPrompts.prompt, orchestratorPrompts.appendPrompt);
-  const oOverride = getAgentOverride(config2, "orchestrator");
-  applyDefaultPermissions(orchestrator, oOverride?.skills);
-  if (oOverride) {
-    applyOverrides(orchestrator, oOverride);
+  applyDefaultPermissions(orchestrator, orchestratorOverride?.skills);
+  if (orchestratorOverride) {
+    applyOverrides(orchestrator, orchestratorOverride);
   }
   return [orchestrator, ...allSubAgents];
 }
@@ -17675,6 +17739,27 @@ function applyAgentVariant(variant, body) {
   }
   return { ...body, variant };
 }
+// src/utils/internal-initiator.ts
+var SLIM_INTERNAL_INITIATOR_MARKER = "<!-- SLIM_INTERNAL_INITIATOR -->";
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function createInternalAgentTextPart(text) {
+  return {
+    type: "text",
+    text: `${text}
+${SLIM_INTERNAL_INITIATOR_MARKER}`
+  };
+}
+function hasInternalInitiatorMarker(part) {
+  if (!isRecord(part) || part.type !== "text") {
+    return false;
+  }
+  if (typeof part.text !== "string") {
+    return false;
+  }
+  return part.text.includes(SLIM_INTERNAL_INITIATOR_MARKER);
+}
 // src/utils/tmux.ts
 var {spawn } = globalThis.Bun;
 var tmuxPath = null;
@@ -18085,7 +18170,15 @@ class BackgroundTaskManager {
     const primary = this.config?.agents?.[agentName]?.model;
     const chain = [];
     const seen = new Set;
-    for (const model of [primary, ...configuredChain]) {
+    let primaryIds;
+    if (Array.isArray(primary)) {
+      primaryIds = primary.map((m) => typeof m === "string" ? m : m.id);
+    } else if (typeof primary === "string") {
+      primaryIds = [primary];
+    } else {
+      primaryIds = [];
+    }
+    for (const model of [...primaryIds, ...configuredChain]) {
       if (!model || seen.has(model))
         continue;
       seen.add(model);
@@ -18094,6 +18187,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 +18240,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 = [];
@@ -18303,7 +18400,7 @@ class BackgroundTaskManager {
     await this.client.session.prompt({
       path: { id: task.parentSessionId },
       body: {
-        parts: [{ type: "text", text: message }]
+        parts: [createInternalAgentTextPart(message)]
       }
     });
   }
@@ -18933,10 +19030,220 @@ function showToast(ctx, title, message, variant = "info", duration3 = 3000) {
     body: { title, message, variant, duration: duration3 }
   }).catch(() => {});
 }
+// src/hooks/chat-headers.ts
+var INTERNAL_MARKER_CACHE_LIMIT = 1000;
+var internalMarkerCache = new Map;
+function getProviderID(input) {
+  return input.provider.info?.id || input.model.providerID;
+}
+function isCopilotProvider(providerID) {
+  return providerID === "github-copilot" || providerID === "github-copilot-enterprise";
+}
+async function hasInternalMarker(client, sessionID, messageID) {
+  const cacheKey = `${sessionID}:${messageID}`;
+  const cached2 = internalMarkerCache.get(cacheKey);
+  if (cached2 !== undefined) {
+    return cached2;
+  }
+  try {
+    const response = await client.session.message({
+      path: { id: sessionID, messageID }
+    });
+    const hasMarker = (response.data?.parts ?? []).some(hasInternalInitiatorMarker);
+    if (hasMarker) {
+      if (internalMarkerCache.size >= INTERNAL_MARKER_CACHE_LIMIT) {
+        internalMarkerCache.clear();
+      }
+      internalMarkerCache.set(cacheKey, true);
+    }
+    return hasMarker;
+  } catch {
+    return false;
+  }
+}
+function createChatHeadersHook(ctx) {
+  return {
+    "chat.headers": async (input, output) => {
+      if (!isCopilotProvider(getProviderID(input))) {
+        return;
+      }
+      if (input.model.api.npm === "@ai-sdk/github-copilot") {
+        return;
+      }
+      if (!input.message.id || input.message.role !== "user") {
+        return;
+      }
+      if (!await hasInternalMarker(ctx.client, input.sessionID, input.message.id)) {
+        return;
+      }
+      output.headers["x-initiator"] = "agent";
+    }
+  };
+}
+// 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) => {
@@ -18964,6 +19271,9 @@ function createPhaseReminderHook() {
         return;
       }
       const originalText = lastUserMessage.parts[textPartIndex].text ?? "";
+      if (originalText.includes(SLIM_INTERNAL_INITIATOR_MARKER)) {
+        return;
+      }
       lastUserMessage.parts[textPartIndex].text = `${PHASE_REMINDER}
 
 ---
@@ -18976,7 +19286,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) => {
@@ -33218,7 +33528,14 @@ var lsp_rename = tool({
 // src/index.ts
 var OhMyOpenCodeLite = async (ctx) => {
   const config3 = loadPluginConfig(ctx.directory);
+  const agentDefs = createAgents(config3);
   const agents = getAgentConfigs(config3);
+  const modelArrayMap = {};
+  for (const agentDef of agentDefs) {
+    if (agentDef._modelArray && agentDef._modelArray.length > 0) {
+      modelArrayMap[agentDef.name] = agentDef._modelArray;
+    }
+  }
   const tmuxConfig = {
     enabled: config3.tmux?.enabled ?? false,
     layout: config3.tmux?.layout ?? "main-vertical",
@@ -33242,6 +33559,9 @@ var OhMyOpenCodeLite = async (ctx) => {
   });
   const phaseReminderHook = createPhaseReminderHook();
   const postReadNudgeHook = createPostReadNudgeHook();
+  const chatHeadersHook = createChatHeadersHook(ctx);
+  const delegateTaskRetryHook = createDelegateTaskRetryHook(ctx);
+  const jsonErrorRecoveryHook = createJsonErrorRecoveryHook(ctx);
   return {
     name: "oh-my-opencode-slim",
     agent: agents,
@@ -33264,6 +33584,40 @@ var OhMyOpenCodeLite = async (ctx) => {
         Object.assign(opencodeConfig.agent, agents);
       }
       const configAgent = opencodeConfig.agent;
+      if (Object.keys(modelArrayMap).length > 0) {
+        const providerConfig = opencodeConfig.provider ?? {};
+        const configuredProviders = Object.keys(providerConfig);
+        for (const [agentName, modelArray] of Object.entries(modelArrayMap)) {
+          let resolved = false;
+          for (const modelEntry of modelArray) {
+            const slashIdx = modelEntry.id.indexOf("/");
+            if (slashIdx === -1)
+              continue;
+            const providerID = modelEntry.id.slice(0, slashIdx);
+            if (configuredProviders.includes(providerID)) {
+              const entry = configAgent[agentName];
+              if (entry) {
+                entry.model = modelEntry.id;
+                if (modelEntry.variant) {
+                  entry.variant = modelEntry.variant;
+                }
+              }
+              log("[plugin] resolved model fallback", {
+                agent: agentName,
+                model: modelEntry.id,
+                variant: modelEntry.variant
+              });
+              resolved = true;
+              break;
+            }
+          }
+          if (!resolved) {
+            log("[plugin] no provider match for model array", {
+              agent: agentName
+            });
+          }
+        }
+      }
       const configMcp = opencodeConfig.mcp;
       if (!configMcp) {
         opencodeConfig.mcp = { ...mcps };
@@ -33300,8 +33654,13 @@ var OhMyOpenCodeLite = async (ctx) => {
       await backgroundManager.handleSessionDeleted(input.event);
       await tmuxSessionManager.onSessionDeleted(input.event);
     },
+    "chat.headers": chatHeadersHook["chat.headers"],
     "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/dist/utils/index.d.ts

@@ -1,5 +1,6 @@
 export * from './agent-variant';
 export * from './env';
+export * from './internal-initiator';
 export { log } from './logger';
 export * from './polling';
 export * from './tmux';

package/dist/utils/internal-initiator.d.ts

@@ -0,0 +1,6 @@
+export declare const SLIM_INTERNAL_INITIATOR_MARKER = "<!-- SLIM_INTERNAL_INITIATOR -->";
+export declare function createInternalAgentTextPart(text: string): {
+    type: 'text';
+    text: string;
+};
+export declare function hasInternalInitiatorMarker(part: unknown): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode-slim",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "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[];
-}