oh-my-opencode 3.1.4 → 3.1.5

package/dist/index.js

@@ -236,6 +236,9 @@ function createSystemDirective(type) {
 function isSystemDirective(text) {
   return text.trimStart().startsWith(SYSTEM_DIRECTIVE_PREFIX);
 }
+function removeSystemReminders(text) {
+  return text.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/gi, "").trim();
+}
 var SYSTEM_DIRECTIVE_PREFIX = "[SYSTEM DIRECTIVE: OH-MY-OPENCODE", SystemDirectiveTypes;
 var init_system_directive = __esm(() => {
   SystemDirectiveTypes = {
@@ -4550,9 +4553,56 @@ var TAURI_APP_IDENTIFIER = "ai.opencode.desktop", TAURI_APP_IDENTIFIER_DEV = "ai
 var init_opencode_config_dir = () => {};
 
 // src/shared/opencode-version.ts
-var NOT_CACHED;
+import { execSync } from "child_process";
+function parseVersion(version) {
+  const cleaned = version.replace(/^v/, "").split("-")[0];
+  return cleaned.split(".").map((n) => parseInt(n, 10) || 0);
+}
+function compareVersions(a, b) {
+  const partsA = parseVersion(a);
+  const partsB = parseVersion(b);
+  const maxLen = Math.max(partsA.length, partsB.length);
+  for (let i2 = 0;i2 < maxLen; i2++) {
+    const numA = partsA[i2] ?? 0;
+    const numB = partsB[i2] ?? 0;
+    if (numA < numB)
+      return -1;
+    if (numA > numB)
+      return 1;
+  }
+  return 0;
+}
+function isVersionGte(a, b) {
+  return compareVersions(a, b) >= 0;
+}
+function getOpenCodeVersion() {
+  if (cachedVersion !== NOT_CACHED) {
+    return cachedVersion;
+  }
+  try {
+    const result = execSync("opencode --version", {
+      encoding: "utf-8",
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const versionMatch = result.match(/(\d+\.\d+\.\d+(?:-[\w.]+)?)/);
+    cachedVersion = versionMatch?.[1] ?? null;
+    return cachedVersion;
+  } catch {
+    cachedVersion = null;
+    return null;
+  }
+}
+function isOpenCodeVersionAtLeast(version) {
+  const current = getOpenCodeVersion();
+  if (!current)
+    return true;
+  return isVersionGte(current, version);
+}
+var OPENCODE_NATIVE_AGENTS_INJECTION_VERSION = "1.1.37", NOT_CACHED, cachedVersion;
 var init_opencode_version = __esm(() => {
   NOT_CACHED = Symbol("NOT_CACHED");
+  cachedVersion = NOT_CACHED;
 });
 
 // src/shared/permission-compat.ts
@@ -4783,6 +4833,131 @@ function equalsIgnoreCase(a, b) {
   return a.toLowerCase() === b.toLowerCase();
 }
 
+// src/shared/model-requirements.ts
+var AGENT_MODEL_REQUIREMENTS, CATEGORY_MODEL_REQUIREMENTS;
+var init_model_requirements = __esm(() => {
+  AGENT_MODEL_REQUIREMENTS = {
+    sisyphus: {
+      fallbackChain: [
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-5", variant: "max" },
+        { providers: ["zai-coding-plan"], model: "glm-4.7" },
+        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2-codex", variant: "medium" },
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro" }
+      ]
+    },
+    oracle: {
+      fallbackChain: [
+        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2", variant: "high" },
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-5", variant: "max" },
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro" }
+      ]
+    },
+    librarian: {
+      fallbackChain: [
+        { providers: ["zai-coding-plan"], model: "glm-4.7" },
+        { providers: ["opencode"], model: "big-pickle" },
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-sonnet-4-5" }
+      ]
+    },
+    explore: {
+      fallbackChain: [
+        { providers: ["anthropic", "opencode"], model: "claude-haiku-4-5" },
+        { providers: ["github-copilot"], model: "gpt-5-mini" },
+        { providers: ["opencode"], model: "gpt-5-nano" }
+      ]
+    },
+    "multimodal-looker": {
+      fallbackChain: [
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-flash" },
+        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2" },
+        { providers: ["zai-coding-plan"], model: "glm-4.6v" },
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-haiku-4-5" },
+        { providers: ["opencode"], model: "gpt-5-nano" }
+      ]
+    },
+    prometheus: {
+      fallbackChain: [
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-5", variant: "max" },
+        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2", variant: "high" },
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro" }
+      ]
+    },
+    metis: {
+      fallbackChain: [
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-5", variant: "max" },
+        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2", variant: "high" },
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro", variant: "max" }
+      ]
+    },
+    momus: {
+      fallbackChain: [
+        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2", variant: "medium" },
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-5" },
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro", variant: "max" }
+      ]
+    },
+    atlas: {
+      fallbackChain: [
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-sonnet-4-5" },
+        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2" },
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro" }
+      ]
+    }
+  };
+  CATEGORY_MODEL_REQUIREMENTS = {
+    "visual-engineering": {
+      fallbackChain: [
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro" },
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-5", variant: "max" },
+        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2", variant: "high" }
+      ]
+    },
+    ultrabrain: {
+      fallbackChain: [
+        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2-codex", variant: "xhigh" },
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-5", variant: "max" },
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro" }
+      ]
+    },
+    artistry: {
+      fallbackChain: [
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro", variant: "max" },
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-5", variant: "max" },
+        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2" }
+      ]
+    },
+    quick: {
+      fallbackChain: [
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-haiku-4-5" },
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-flash" },
+        { providers: ["opencode"], model: "gpt-5-nano" }
+      ]
+    },
+    "unspecified-low": {
+      fallbackChain: [
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-sonnet-4-5" },
+        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2-codex", variant: "medium" },
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-flash" }
+      ]
+    },
+    "unspecified-high": {
+      fallbackChain: [
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-5", variant: "max" },
+        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2", variant: "high" },
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro" }
+      ]
+    },
+    writing: {
+      fallbackChain: [
+        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-flash" },
+        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-sonnet-4-5" },
+        { providers: ["zai-coding-plan"], model: "glm-4.7" },
+        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2" }
+      ]
+    }
+  };
+});
+
 // src/shared/agent-variant.ts
 function resolveAgentVariant(config, agentName) {
   if (!agentName) {
@@ -4802,13 +4977,39 @@ function resolveAgentVariant(config, agentName) {
   }
   return config.categories?.[categoryName]?.variant;
 }
+function resolveVariantForModel(config, agentName, currentModel) {
+  const agentRequirement = AGENT_MODEL_REQUIREMENTS[agentName];
+  if (agentRequirement) {
+    return findVariantInChain(agentRequirement.fallbackChain, currentModel.providerID);
+  }
+  const agentOverrides = config.agents;
+  const agentOverride = agentOverrides ? findCaseInsensitive(agentOverrides, agentName) : undefined;
+  const categoryName = agentOverride?.category;
+  if (categoryName) {
+    const categoryRequirement = CATEGORY_MODEL_REQUIREMENTS[categoryName];
+    if (categoryRequirement) {
+      return findVariantInChain(categoryRequirement.fallbackChain, currentModel.providerID);
+    }
+  }
+  return;
+}
+function findVariantInChain(fallbackChain, providerID) {
+  for (const entry of fallbackChain) {
+    if (entry.providers.includes(providerID)) {
+      return entry.variant;
+    }
+  }
+  return;
+}
 function applyAgentVariant(config, agentName, message) {
   const variant = resolveAgentVariant(config, agentName);
   if (variant !== undefined && message.variant === undefined) {
     message.variant = variant;
   }
 }
-var init_agent_variant = () => {};
+var init_agent_variant = __esm(() => {
+  init_model_requirements();
+});
 
 // src/shared/session-cursor.ts
 function buildMessageKey(message, index) {
@@ -4942,131 +5143,6 @@ var init_agent_tool_restrictions = __esm(() => {
   };
 });
 
-// src/shared/model-requirements.ts
-var AGENT_MODEL_REQUIREMENTS, CATEGORY_MODEL_REQUIREMENTS;
-var init_model_requirements = __esm(() => {
-  AGENT_MODEL_REQUIREMENTS = {
-    sisyphus: {
-      fallbackChain: [
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-5", variant: "max" },
-        { providers: ["zai-coding-plan"], model: "glm-4.7" },
-        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2-codex", variant: "medium" },
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro" }
-      ]
-    },
-    oracle: {
-      fallbackChain: [
-        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2", variant: "high" },
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-5", variant: "max" },
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro" }
-      ]
-    },
-    librarian: {
-      fallbackChain: [
-        { providers: ["zai-coding-plan"], model: "glm-4.7" },
-        { providers: ["opencode"], model: "big-pickle" },
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-sonnet-4-5" }
-      ]
-    },
-    explore: {
-      fallbackChain: [
-        { providers: ["anthropic", "opencode"], model: "claude-haiku-4-5" },
-        { providers: ["github-copilot"], model: "gpt-5-mini" },
-        { providers: ["opencode"], model: "gpt-5-nano" }
-      ]
-    },
-    "multimodal-looker": {
-      fallbackChain: [
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-flash" },
-        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2" },
-        { providers: ["zai-coding-plan"], model: "glm-4.6v" },
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-haiku-4-5" },
-        { providers: ["opencode"], model: "gpt-5-nano" }
-      ]
-    },
-    prometheus: {
-      fallbackChain: [
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-5", variant: "max" },
-        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2", variant: "high" },
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro" }
-      ]
-    },
-    metis: {
-      fallbackChain: [
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-5", variant: "max" },
-        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2", variant: "high" },
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro", variant: "max" }
-      ]
-    },
-    momus: {
-      fallbackChain: [
-        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2", variant: "medium" },
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-5" },
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro", variant: "max" }
-      ]
-    },
-    atlas: {
-      fallbackChain: [
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-sonnet-4-5" },
-        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2" },
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro" }
-      ]
-    }
-  };
-  CATEGORY_MODEL_REQUIREMENTS = {
-    "visual-engineering": {
-      fallbackChain: [
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro" },
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-5", variant: "max" },
-        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2", variant: "high" }
-      ]
-    },
-    ultrabrain: {
-      fallbackChain: [
-        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2-codex", variant: "xhigh" },
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-5", variant: "max" },
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro" }
-      ]
-    },
-    artistry: {
-      fallbackChain: [
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro", variant: "max" },
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-5", variant: "max" },
-        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2" }
-      ]
-    },
-    quick: {
-      fallbackChain: [
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-haiku-4-5" },
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-flash" },
-        { providers: ["opencode"], model: "gpt-5-nano" }
-      ]
-    },
-    "unspecified-low": {
-      fallbackChain: [
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-sonnet-4-5" },
-        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2-codex", variant: "medium" },
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-flash" }
-      ]
-    },
-    "unspecified-high": {
-      fallbackChain: [
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-opus-4-5", variant: "max" },
-        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2", variant: "high" },
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-pro" }
-      ]
-    },
-    writing: {
-      fallbackChain: [
-        { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-flash" },
-        { providers: ["anthropic", "github-copilot", "opencode"], model: "claude-sonnet-4-5" },
-        { providers: ["zai-coding-plan"], model: "glm-4.7" },
-        { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.2" }
-      ]
-    }
-  };
-});
-
 // src/shared/connected-providers-cache.ts
 import { existsSync as existsSync9, readFileSync as readFileSync6, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3 } from "fs";
 import { join as join12 } from "path";
@@ -7531,9 +7607,9 @@ v${latestVersion} available. Restart OpenCode to apply.` : `OpenCode is now on S
         return;
       hasChecked = true;
       setTimeout(async () => {
-        const cachedVersion = getCachedVersion();
+        const cachedVersion2 = getCachedVersion();
         const localDevVersion = getLocalDevVersion(ctx.directory);
-        const displayVersion = localDevVersion ?? cachedVersion;
+        const displayVersion = localDevVersion ?? cachedVersion2;
         await showConfigErrorsIfAny(ctx);
         await showModelCacheWarningIfNeeded(ctx);
         await updateAndShowConnectedProvidersCacheStatus(ctx);
@@ -7560,8 +7636,8 @@ async function runBackgroundUpdateCheck(ctx, autoUpdate, getToastMessage) {
     log("[auto-update-checker] Plugin not found in config");
     return;
   }
-  const cachedVersion = getCachedVersion();
-  const currentVersion = cachedVersion ?? pluginInfo.pinnedVersion;
+  const cachedVersion2 = getCachedVersion();
+  const currentVersion = cachedVersion2 ?? pluginInfo.pinnedVersion;
   if (!currentVersion) {
     log("[auto-update-checker] No version found (cached or pinned)");
     return;
@@ -18505,7 +18581,7 @@ async function executePreToolUseHooks(ctx, config, extendedConfig) {
       }
       if (result.stdout) {
         try {
-          const output = JSON.parse(result.stdout);
+          const output = JSON.parse(result.stdout || "{}");
           let decision;
           let reason;
           let modifiedInput;
@@ -18741,7 +18817,7 @@ ${result.stderr.trim()}`);
         }
         if (result.exitCode === 0 && result.stdout) {
           try {
-            const output = JSON.parse(result.stdout);
+            const output = JSON.parse(result.stdout || "{}");
             if (output.decision === "block") {
               return {
                 block: true,
@@ -18934,7 +19010,7 @@ async function executeStopHooks(ctx, config, extendedConfig) {
       }
       if (result.stdout) {
         try {
-          const output = JSON.parse(result.stdout);
+          const output = JSON.parse(result.stdout || "{}");
           if (output.stop_hook_active !== undefined) {
             stopHookActiveState.set(ctx.sessionId, output.stop_hook_active);
           }
@@ -18991,7 +19067,7 @@ async function executePreCompactHooks(ctx, config, extendedConfig) {
       }
       if (result.stdout) {
         try {
-          const output = JSON.parse(result.stdout);
+          const output = JSON.parse(result.stdout || "{}");
           if (output.hookSpecificOutput?.additionalContext) {
             collectedContext.push(...output.hookSpecificOutput.additionalContext);
           } else if (output.context) {
@@ -19194,6 +19270,9 @@ ${result.inputLines ?? ""}`,
       }
     },
     "tool.execute.after": async (input, output) => {
+      if (!output) {
+        return;
+      }
       const claudeConfig = await loadClaudeHooksConfig();
       const extendedConfig = await loadPluginExtendedConfig();
       const cachedInput = getToolInput(input.sessionID, input.tool, input.callID) || {};
@@ -20064,7 +20143,81 @@ You ARE the planner. Your job: create bulletproof work plans.
 - External library APIs and constraints
 - Similar implementations in OSS (via librarian)
 
-**NEVER plan blind. Context first, plan second.**`;
+**NEVER plan blind. Context first, plan second.**
+
+---
+
+## MANDATORY OUTPUT: PARALLEL TASK GRAPH + TODO LIST
+
+**YOUR PRIMARY OUTPUT IS A PARALLEL EXECUTION TASK GRAPH.**
+
+When you finalize a plan, you MUST structure it for maximum parallel execution:
+
+### 1. Parallel Execution Waves (REQUIRED)
+
+Analyze task dependencies and group independent tasks into parallel waves:
+
+\`\`\`
+Wave 1 (Start Immediately - No Dependencies):
+\u251C\u2500\u2500 Task 1: [description] \u2192 category: X, skills: [a, b]
+\u2514\u2500\u2500 Task 4: [description] \u2192 category: Y, skills: [c]
+
+Wave 2 (After Wave 1 Completes):
+\u251C\u2500\u2500 Task 2: [depends: 1] \u2192 category: X, skills: [a]
+\u251C\u2500\u2500 Task 3: [depends: 1] \u2192 category: Z, skills: [d]
+\u2514\u2500\u2500 Task 5: [depends: 4] \u2192 category: Y, skills: [c]
+
+Wave 3 (After Wave 2 Completes):
+\u2514\u2500\u2500 Task 6: [depends: 2, 3] \u2192 category: X, skills: [a, b]
+
+Critical Path: Task 1 \u2192 Task 2 \u2192 Task 6
+Estimated Parallel Speedup: ~40% faster than sequential
+\`\`\`
+
+### 2. Dependency Matrix (REQUIRED)
+
+| Task | Depends On | Blocks | Can Parallelize With |
+|------|------------|--------|---------------------|
+| 1 | None | 2, 3 | 4 |
+| 2 | 1 | 6 | 3, 5 |
+| 3 | 1 | 6 | 2, 5 |
+| 4 | None | 5 | 1 |
+| 5 | 4 | None | 2, 3 |
+| 6 | 2, 3 | None | None (final) |
+
+### 3. TODO List Structure (REQUIRED)
+
+Each TODO item MUST include:
+
+\`\`\`markdown
+- [ ] N. [Task Title]
+
+  **What to do**: [Clear steps]
+  
+  **Dependencies**: [Task numbers this depends on] | None
+  **Blocks**: [Task numbers that depend on this]
+  **Parallel Group**: Wave N (with Tasks X, Y)
+  
+  **Recommended Agent Profile**:
+  - **Category**: \`[visual-engineering | ultrabrain | artistry | quick | unspecified-low | unspecified-high | writing]\`
+  - **Skills**: [\`skill-1\`, \`skill-2\`]
+  
+  **Acceptance Criteria**: [Verifiable conditions]
+\`\`\`
+
+### 4. Agent Dispatch Summary (REQUIRED)
+
+| Wave | Tasks | Dispatch Command |
+|------|-------|------------------|
+| 1 | 1, 4 | \`delegate_task(category="...", load_skills=[...], run_in_background=true)\` \xD7 2 |
+| 2 | 2, 3, 5 | \`delegate_task(...)\` \xD7 3 after Wave 1 completes |
+| 3 | 6 | \`delegate_task(...)\` final integration |
+
+**WHY PARALLEL TASK GRAPH IS MANDATORY:**
+- Orchestrator (Sisyphus) executes tasks in parallel waves
+- Independent tasks run simultaneously via background agents
+- Proper dependency tracking prevents race conditions
+- Category + skills ensure optimal model routing per task`;
 function isPlannerAgent(agentName) {
   if (!agentName)
     return false;
@@ -20169,52 +20322,52 @@ delegate_task(agent="oracle", prompt="Review my approach: [describe plan]")
 YOU MUST LEVERAGE ALL AVAILABLE AGENTS / **CATEGORY + SKILLS** TO THEIR FULLEST POTENTIAL.
 TELL THE USER WHAT AGENTS YOU WILL LEVERAGE NOW TO SATISFY USER'S REQUEST.
 
-## MANDATORY: PROMETHEUS AGENT INVOCATION (NON-NEGOTIABLE)
+## MANDATORY: PLAN AGENT INVOCATION (NON-NEGOTIABLE)
 
-**YOU MUST ALWAYS INVOKE PROMETHEUS (THE PLANNER) FOR ANY NON-TRIVIAL TASK.**
+**YOU MUST ALWAYS INVOKE THE PLAN AGENT FOR ANY NON-TRIVIAL TASK.**
 
 | Condition | Action |
 |-----------|--------|
-| Task has 2+ steps | MUST call Prometheus |
-| Task scope unclear | MUST call Prometheus |
-| Implementation required | MUST call Prometheus |
-| Architecture decision needed | MUST call Prometheus |
+| Task has 2+ steps | MUST call plan agent |
+| Task scope unclear | MUST call plan agent |
+| Implementation required | MUST call plan agent |
+| Architecture decision needed | MUST call plan agent |
 
 \`\`\`
-delegate_task(subagent_type="prometheus", prompt="<gathered context + user request>")
+delegate_task(subagent_type="plan", prompt="<gathered context + user request>")
 \`\`\`
 
-**WHY PROMETHEUS IS MANDATORY:**
-- Prometheus analyzes dependencies and parallel execution opportunities
-- Prometheus recommends CATEGORY + SKILLS for each task (in TL;DR + per-task)
-- Prometheus ensures nothing is missed with structured work plans
+**WHY PLAN AGENT IS MANDATORY:**
+- Plan agent analyzes dependencies and parallel execution opportunities
+- Plan agent outputs a **parallel task graph** with waves and dependencies
+- Plan agent provides structured TODO list with category + skills per task
 - YOU are an orchestrator, NOT an implementer
 
-### SESSION CONTINUITY WITH PROMETHEUS (CRITICAL)
+### SESSION CONTINUITY WITH PLAN AGENT (CRITICAL)
 
-**Prometheus returns a session_id. USE IT for follow-up interactions.**
+**Plan agent returns a session_id. USE IT for follow-up interactions.**
 
 | Scenario | Action |
 |----------|--------|
-| Prometheus asks clarifying questions | \`delegate_task(session_id="{returned_session_id}", prompt="<your answer>")\` |
+| Plan agent asks clarifying questions | \`delegate_task(session_id="{returned_session_id}", prompt="<your answer>")\` |
 | Need to refine the plan | \`delegate_task(session_id="{returned_session_id}", prompt="Please adjust: <feedback>")\` |
 | Plan needs more detail | \`delegate_task(session_id="{returned_session_id}", prompt="Add more detail to Task N")\` |
 
 **WHY SESSION_ID IS CRITICAL:**
-- Prometheus retains FULL conversation context
+- Plan agent retains FULL conversation context
 - No repeated exploration or context gathering
 - Saves 70%+ tokens on follow-ups
 - Maintains interview continuity until plan is finalized
 
 \`\`\`
 // WRONG: Starting fresh loses all context
-delegate_task(subagent_type="prometheus", prompt="Here's more info...")
+delegate_task(subagent_type="plan", prompt="Here's more info...")
 
 // CORRECT: Resume preserves everything
 delegate_task(session_id="ses_abc123", prompt="Here's my answer to your question: ...")
 \`\`\`
 
-**FAILURE TO CALL PROMETHEUS = INCOMPLETE WORK.**
+**FAILURE TO CALL PLAN AGENT = INCOMPLETE WORK.**
 
 ---
 
@@ -20226,7 +20379,7 @@ delegate_task(session_id="ses_abc123", prompt="Here's my answer to your question
 |-----------|--------|-----|
 | Codebase exploration | delegate_task(subagent_type="explore", run_in_background=true) | Parallel, context-efficient |
 | Documentation lookup | delegate_task(subagent_type="librarian", run_in_background=true) | Specialized knowledge |
-| Planning | delegate_task(subagent_type="plan") | Structured work breakdown |
+| Planning | delegate_task(subagent_type="plan") | Parallel task graph + structured TODO list |
 | Architecture/Debugging | delegate_task(subagent_type="oracle") | High-IQ reasoning |
 | Implementation | delegate_task(category="...", load_skills=[...]) | Domain-optimized models |
 
@@ -20286,20 +20439,20 @@ delegate_task(..., run_in_background=true)  // task_id_3
    delegate_task(subagent_type="librarian", run_in_background=true, prompt="...")
    \`\`\`
 
-2. **INVOKE PROMETHEUS** (MANDATORY for non-trivial tasks):
+2. **INVOKE PLAN AGENT** (MANDATORY for non-trivial tasks):
    \`\`\`
-   result = delegate_task(subagent_type="prometheus", prompt="<context + request>")
+   result = delegate_task(subagent_type="plan", prompt="<context + request>")
    // STORE the session_id for follow-ups!
-   prometheus_session_id = result.session_id
+   plan_session_id = result.session_id
    \`\`\`
 
-3. **ITERATE WITH PROMETHEUS** (if clarification needed):
+3. **ITERATE WITH PLAN AGENT** (if clarification needed):
    \`\`\`
    // Use session_id to continue the conversation
-   delegate_task(session_id=prometheus_session_id, prompt="<answer to Prometheus's question>")
+   delegate_task(session_id=plan_session_id, prompt="<answer to plan agent's question>")
    \`\`\`
 
-4. **EXECUTE VIA DELEGATION** (category + skills from Prometheus's plan):
+4. **EXECUTE VIA DELEGATION** (category + skills from plan agent's output):
    \`\`\`
    delegate_task(category="...", load_skills=[...], prompt="<task from plan>")
    \`\`\`
@@ -20378,9 +20531,9 @@ Write these criteria explicitly. Share with user if scope is non-trivial.
 THE USER ASKED FOR X. DELIVER EXACTLY X. NOT A SUBSET. NOT A DEMO. NOT A STARTING POINT.
 
 1. EXPLORES + LIBRARIANS (background)
-2. GATHER -> delegate_task(subagent_type="prometheus", prompt="<context + request>")
-3. ITERATE WITH PROMETHEUS (session_id resume) UNTIL PLAN IS FINALIZED
-4. WORK BY DELEGATING TO CATEGORY + SKILLS AGENTS (following Prometheus's plan)
+2. GATHER -> delegate_task(subagent_type="plan", prompt="<context + request>")
+3. ITERATE WITH PLAN AGENT (session_id resume) UNTIL PLAN IS FINALIZED
+4. WORK BY DELEGATING TO CATEGORY + SKILLS AGENTS (following plan agent's parallel task graph)
 
 NOW.
 
@@ -20453,7 +20606,8 @@ function createKeywordDetectorHook(ctx, collector) {
         return;
       }
       const currentAgent = getSessionAgent(input.sessionID) ?? input.agent;
-      let detectedKeywords = detectKeywordsWithType(removeCodeBlocks2(promptText), currentAgent);
+      const cleanText = removeSystemReminders(promptText);
+      let detectedKeywords = detectKeywordsWithType(removeCodeBlocks2(cleanText), currentAgent);
       if (isPlannerAgent(currentAgent)) {
         detectedKeywords = detectedKeywords.filter((k) => k.type !== "ultrawork");
       }
@@ -21577,6 +21731,9 @@ async function loadMcpJsonFromDir(skillDir) {
 function parseAllowedTools(allowedTools) {
   if (!allowedTools)
     return;
+  if (Array.isArray(allowedTools)) {
+    return allowedTools.map((t) => t.trim()).filter(Boolean);
+  }
   return allowedTools.split(/\s+/).filter(Boolean);
 }
 async function loadSkillFromPath(skillPath, resolvedPath, defaultName, scope) {
@@ -21744,6 +21901,14 @@ init_deep_merge();
 import { readFileSync as readFileSync21, existsSync as existsSync31 } from "fs";
 import { dirname as dirname7, resolve as resolve6, isAbsolute as isAbsolute2 } from "path";
 import { homedir as homedir10 } from "os";
+function parseAllowedToolsFromMetadata(allowedTools) {
+  if (!allowedTools)
+    return;
+  if (Array.isArray(allowedTools)) {
+    return allowedTools.map((t) => t.trim()).filter(Boolean);
+  }
+  return allowedTools.split(/\s+/).filter(Boolean);
+}
 var SCOPE_PRIORITY = {
   builtin: 1,
   config: 2,
@@ -21835,7 +22000,7 @@ $ARGUMENTS
     subtask: entry.subtask ?? fileMetadata.subtask,
     argumentHint: entry["argument-hint"] || fileMetadata["argument-hint"]
   };
-  const allowedTools = entry["allowed-tools"] || (fileMetadata["allowed-tools"] ? fileMetadata["allowed-tools"].split(/\s+/).filter(Boolean) : undefined);
+  const allowedTools = entry["allowed-tools"] || (fileMetadata["allowed-tools"] ? parseAllowedToolsFromMetadata(fileMetadata["allowed-tools"]) : undefined);
   return {
     name,
     path: entry.from ? resolveFilePath2(entry.from, configDir) : undefined,
@@ -24617,7 +24782,7 @@ ${contextInfo}`;
   };
 }
 // src/hooks/atlas/index.ts
-import { execSync } from "child_process";
+import { execSync as execSync2 } from "child_process";
 init_hook_message_injector();
 init_logger();
 init_system_directive();
@@ -24856,7 +25021,7 @@ function extractSessionIdFromOutput(output) {
 }
 function getGitDiffStats(directory) {
   try {
-    const output = execSync("git diff --numstat HEAD", {
+    const output = execSync2("git diff --numstat HEAD", {
       cwd: directory,
       encoding: "utf-8",
       timeout: 5000,
@@ -24864,7 +25029,7 @@ function getGitDiffStats(directory) {
     }).trim();
     if (!output)
       return [];
-    const statusOutput = execSync("git status --porcelain", {
+    const statusOutput = execSync2("git status --porcelain", {
       cwd: directory,
       encoding: "utf-8",
       timeout: 5000,
@@ -25161,6 +25326,9 @@ function createAtlasHook(ctx, options) {
       }
     },
     "tool.execute.after": async (input, output) => {
+      if (!output) {
+        return;
+      }
       if (!isCallerOrchestrator(input.sessionID)) {
         return;
       }
@@ -43589,7 +43757,10 @@ async function executeSync(args, toolContext, ctx) {
     const createResult = await ctx.client.session.create({
       body: {
         parentID: toolContext.sessionID,
-        title: `${args.description} (@${args.subagent_type} subagent)`
+        title: `${args.description} (@${args.subagent_type} subagent)`,
+        permission: [
+          { permission: "question", action: "deny", pattern: "*" }
+        ]
       },
       query: {
         directory: parentDirectory
@@ -43597,6 +43768,17 @@ async function executeSync(args, toolContext, ctx) {
     });
     if (createResult.error) {
       log(`[call_omo_agent] Session create error:`, createResult.error);
+      const errorStr = String(createResult.error);
+      if (errorStr.toLowerCase().includes("unauthorized")) {
+        return `Error: Failed to create session (Unauthorized). This may be due to:
+1. OAuth token restrictions (e.g., Claude Code credentials are restricted to Claude Code only)
+2. Provider authentication issues
+3. Session permission inheritance problems
+
+Try using a different provider or API key authentication.
+
+Original error: ${createResult.error}`;
+      }
       return `Error: Failed to create session: ${createResult.error}`;
     }
     sessionID = createResult.data.id;
@@ -43837,7 +44019,10 @@ If the requested information is not found, clearly state what is missing.`;
       const createResult = await ctx.client.session.create({
         body: {
           parentID: toolContext.sessionID,
-          title: `look_at: ${args.goal.substring(0, 50)}`
+          title: `look_at: ${args.goal.substring(0, 50)}`,
+          permission: [
+            { permission: "question", action: "deny", pattern: "*" }
+          ]
         },
         query: {
           directory: parentDirectory
@@ -43845,6 +44030,17 @@ If the requested information is not found, clearly state what is missing.`;
       });
       if (createResult.error) {
         log(`[look_at] Session create error:`, createResult.error);
+        const errorStr = String(createResult.error);
+        if (errorStr.toLowerCase().includes("unauthorized")) {
+          return `Error: Failed to create session (Unauthorized). This may be due to:
+1. OAuth token restrictions (e.g., Claude Code credentials are restricted to Claude Code only)
+2. Provider authentication issues
+3. Session permission inheritance problems
+
+Try using a different provider or API key authentication.
+
+Original error: ${createResult.error}`;
+        }
         return `Error: Failed to create session: ${createResult.error}`;
       }
       const sessionID = createResult.data.id;
@@ -44681,6 +44877,11 @@ To continue this session: session_id="${sessionID}"`;
           return `Cannot use subagent_type="${SISYPHUS_JUNIOR_AGENT}" directly. Use category parameter instead (e.g., ${categoryExamples}).
 
 Sisyphus-Junior is spawned automatically when you specify a category. Pick the appropriate category for your task domain.`;
+        }
+        if (isPlanAgent(agentName) && isPlanAgent(parentAgent)) {
+          return `You are prometheus. You cannot delegate to prometheus via delegate_task.
+
+Create the work plan directly - that's your job as the planning agent.`;
         }
         agentToUse = agentName;
         try {
@@ -44809,6 +45010,7 @@ To continue this session: session_id="${task.sessionID}"`;
           }
         });
         try {
+          const allowDelegateTask = isPlanAgent(agentToUse);
           await client2.session.prompt({
             path: { id: sessionID },
             body: {
@@ -44816,7 +45018,7 @@ To continue this session: session_id="${task.sessionID}"`;
               system: systemContent,
               tools: {
                 task: false,
-                delegate_task: false,
+                delegate_task: allowDelegateTask,
                 call_omo_agent: true,
                 question: false
               },
@@ -52919,6 +53121,8 @@ call_omo_agent(subagent_type="librarian", prompt="Find OSS implementations of Z.
 - [Risk 2]: [Mitigation]
 
 ## Directives for Prometheus
+
+### Core Directives
 - MUST: [Required action]
 - MUST: [Required action]
 - MUST NOT: [Forbidden action]
@@ -52926,6 +53130,29 @@ call_omo_agent(subagent_type="librarian", prompt="Find OSS implementations of Z.
 - PATTERN: Follow \`[file:lines]\`
 - TOOL: Use \`[specific tool]\` for [purpose]
 
+### QA/Acceptance Criteria Directives (MANDATORY)
+> **ZERO USER INTERVENTION PRINCIPLE**: All acceptance criteria MUST be executable by agents.
+
+- MUST: Write acceptance criteria as executable commands (curl, bun test, playwright actions)
+- MUST: Include exact expected outputs, not vague descriptions
+- MUST: Specify verification tool for each deliverable type (playwright for UI, curl for API, etc.)
+- MUST NOT: Create criteria requiring "user manually tests..."
+- MUST NOT: Create criteria requiring "user visually confirms..."
+- MUST NOT: Create criteria requiring "user clicks/interacts..."
+- MUST NOT: Use placeholders without concrete examples (bad: "[endpoint]", good: "/api/users")
+
+Example of GOOD acceptance criteria:
+\`\`\`
+curl -s http://localhost:3000/api/health | jq '.status'
+# Assert: Output is "ok"
+\`\`\`
+
+Example of BAD acceptance criteria (FORBIDDEN):
+\`\`\`
+User opens browser and checks if the page loads correctly.
+User confirms the button works as expected.
+\`\`\`
+
 ## Recommended Approach
 [1-2 sentence summary of how to proceed]
 \`\`\`
@@ -52952,12 +53179,16 @@ call_omo_agent(subagent_type="librarian", prompt="Find OSS implementations of Z.
 - Ask generic questions ("What's the scope?")
 - Proceed without addressing ambiguity
 - Make assumptions about user's codebase
+- Suggest acceptance criteria requiring user intervention ("user manually tests", "user confirms", "user clicks")
+- Leave QA/acceptance criteria vague or placeholder-heavy
 
 **ALWAYS**:
 - Classify intent FIRST
 - Be specific ("Should this change UserService only, or also AuthService?")
 - Explore before asking (for Build/Research intents)
 - Provide actionable directives for Prometheus
+- Include QA automation directives in every output
+- Ensure acceptance criteria are agent-executable (commands, not human actions)
 `;
 var metisRestrictions = createAgentToolRestrictions([
   "write",
@@ -55714,27 +55945,37 @@ Each TODO follows RED-GREEN-REFACTOR:
   - Example: Create \`src/__tests__/example.test.ts\`
   - Verify: \`bun test\` \u2192 1 test passes
 
-### If Manual QA Only
+### If Automated Verification Only (NO User Intervention)
 
-**CRITICAL**: Without automated tests, manual verification MUST be exhaustive.
+> **CRITICAL PRINCIPLE: ZERO USER INTERVENTION**
+>
+> **NEVER** create acceptance criteria that require:
+> - "User manually tests..." / "\uC0AC\uC6A9\uC790\uAC00 \uC9C1\uC811 \uD14C\uC2A4\uD2B8..."
+> - "User visually confirms..." / "\uC0AC\uC6A9\uC790\uAC00 \uB208\uC73C\uB85C \uD655\uC778..."
+> - "User interacts with..." / "\uC0AC\uC6A9\uC790\uAC00 \uC9C1\uC811 \uC870\uC791..."
+> - "Ask user to verify..." / "\uC0AC\uC6A9\uC790\uC5D0\uAC8C \uD655\uC778 \uC694\uCCAD..."
+> - ANY step that requires a human to perform an action
+>
+> **ALL verification MUST be automated and executable by the agent.**
+> If a verification cannot be automated, find an automated alternative or explicitly note it as a known limitation.
 
-Each TODO includes detailed verification procedures:
+Each TODO includes EXECUTABLE verification procedures that agents can run directly:
 
 **By Deliverable Type:**
 
-| Type | Verification Tool | Procedure |
-|------|------------------|-----------|
-| **Frontend/UI** | Playwright browser | Navigate, interact, screenshot |
-| **TUI/CLI** | interactive_bash (tmux) | Run command, verify output |
-| **API/Backend** | curl / httpie | Send request, verify response |
-| **Library/Module** | Node/Python REPL | Import, call, verify |
-| **Config/Infra** | Shell commands | Apply, verify state |
+| Type | Verification Tool | Automated Procedure |
+|------|------------------|---------------------|
+| **Frontend/UI** | Playwright browser via playwright skill | Agent navigates, clicks, screenshots, asserts DOM state |
+| **TUI/CLI** | interactive_bash (tmux) | Agent runs command, captures output, validates expected strings |
+| **API/Backend** | curl / httpie via Bash | Agent sends request, parses response, validates JSON fields |
+| **Library/Module** | Node/Python REPL via Bash | Agent imports, calls function, compares output |
+| **Config/Infra** | Shell commands via Bash | Agent applies config, runs state check, validates output |
 
-**Evidence Required:**
-- Commands run with actual output
-- Screenshots for visual changes
-- Response bodies for API changes
-- Terminal output for CLI changes
+**Evidence Requirements (Agent-Executable):**
+- Command output captured and compared against expected patterns
+- Screenshots saved to .sisyphus/evidence/ for visual verification
+- JSON response fields validated with specific assertions
+- Exit codes checked (0 = success)
 
 ---
 
@@ -55844,53 +56085,76 @@ Parallel Speedup: ~40% faster than sequential
 
   **Acceptance Criteria**:
 
-  > CRITICAL: Acceptance = EXECUTION, not just "it should work".
-  > The executor MUST run these commands and verify output.
+  > **CRITICAL: AGENT-EXECUTABLE VERIFICATION ONLY**
+  >
+  > - Acceptance = EXECUTION by the agent, not "user checks if it works"
+  > - Every criterion MUST be verifiable by running a command or using a tool
+  > - NO steps like "user opens browser", "user clicks", "user confirms"
+  > - If you write "[placeholder]" - REPLACE IT with actual values based on task context
 
   **If TDD (tests enabled):**
-  - [ ] Test file created: \`[path].test.ts\`
-  - [ ] Test covers: [specific scenario]
-  - [ ] \`bun test [file]\` \u2192 PASS (N tests, 0 failures)
-
-  **Manual Execution Verification (ALWAYS include, even with tests):**
-
-  *Choose based on deliverable type:*
-
-  **For Frontend/UI changes:**
-  - [ ] Using playwright browser automation:
-    - Navigate to: \`http://localhost:[port]/[path]\`
-    - Action: [click X, fill Y, scroll to Z]
-    - Verify: [visual element appears, animation completes, state changes]
-    - Screenshot: Save evidence to \`.sisyphus/evidence/[task-id]-[step].png\`
-
-  **For TUI/CLI changes:**
-  - [ ] Using interactive_bash (tmux session):
-    - Command: \`[exact command to run]\`
-    - Input sequence: [if interactive, list inputs]
-    - Expected output contains: \`[expected string or pattern]\`
-    - Exit code: [0 for success, specific code if relevant]
-
-  **For API/Backend changes:**
-  - [ ] Request: \`curl -X [METHOD] http://localhost:[port]/[endpoint] -H "Content-Type: application/json" -d '[body]'\`
-  - [ ] Response status: [200/201/etc]
-  - [ ] Response body contains: \`{"key": "expected_value"}\`
-
-  **For Library/Module changes:**
-  - [ ] REPL verification:
-    \`\`\`
-    > import { [function] } from '[module]'
-    > [function]([args])
-    Expected: [output]
-    \`\`\`
-
-  **For Config/Infra changes:**
-  - [ ] Apply: \`[command to apply config]\`
-  - [ ] Verify state: \`[command to check state]\` \u2192 \`[expected output]\`
-
-  **Evidence Required:**
-  - [ ] Command output captured (copy-paste actual terminal output)
-  - [ ] Screenshot saved (for visual changes)
-  - [ ] Response body logged (for API changes)
+  - [ ] Test file created: src/auth/login.test.ts
+  - [ ] Test covers: successful login returns JWT token
+  - [ ] bun test src/auth/login.test.ts \u2192 PASS (3 tests, 0 failures)
+
+  **Automated Verification (ALWAYS include, choose by deliverable type):**
+
+  **For Frontend/UI changes** (using playwright skill):
+  \\\`\\\`\\\`
+  # Agent executes via playwright browser automation:
+  1. Navigate to: http://localhost:3000/login
+  2. Fill: input[name="email"] with "test@example.com"
+  3. Fill: input[name="password"] with "password123"
+  4. Click: button[type="submit"]
+  5. Wait for: selector ".dashboard-welcome" to be visible
+  6. Assert: text "Welcome back" appears on page
+  7. Screenshot: .sisyphus/evidence/task-1-login-success.png
+  \\\`\\\`\\\`
+
+  **For TUI/CLI changes** (using interactive_bash):
+  \\\`\\\`\\\`
+  # Agent executes via tmux session:
+  1. Command: ./my-cli --config test.yaml
+  2. Wait for: "Configuration loaded" in output
+  3. Send keys: "q" to quit
+  4. Assert: Exit code 0
+  5. Assert: Output contains "Goodbye"
+  \\\`\\\`\\\`
+
+  **For API/Backend changes** (using Bash curl):
+  \\\`\\\`\\\`bash
+  # Agent runs:
+  curl -s -X POST http://localhost:8080/api/users \\
+    -H "Content-Type: application/json" \\
+    -d '{"email":"new@test.com","name":"Test User"}' \\
+    | jq '.id'
+  # Assert: Returns non-empty UUID
+  # Assert: HTTP status 201
+  \\\`\\\`\\\`
+
+  **For Library/Module changes** (using Bash node/bun):
+  \\\`\\\`\\\`bash
+  # Agent runs:
+  bun -e "import { validateEmail } from './src/utils/validate'; console.log(validateEmail('test@example.com'))"
+  # Assert: Output is "true"
+  
+  bun -e "import { validateEmail } from './src/utils/validate'; console.log(validateEmail('invalid'))"
+  # Assert: Output is "false"
+  \\\`\\\`\\\`
+
+  **For Config/Infra changes** (using Bash):
+  \\\`\\\`\\\`bash
+  # Agent runs:
+  docker compose up -d
+  # Wait 5s for containers
+  docker compose ps --format json | jq '.[].State'
+  # Assert: All states are "running"
+  \\\`\\\`\\\`
+
+  **Evidence to Capture:**
+  - [ ] Terminal output from verification commands (actual output, not expected)
+  - [ ] Screenshot files in .sisyphus/evidence/ for UI changes
+  - [ ] JSON response bodies for API changes
 
   **Commit**: YES | NO (groups with N)
   - Message: \`type(scope): desc\`
@@ -56292,7 +56556,20 @@ var OhMyOpenCodePlugin = async (ctx) => {
   const toolOutputTruncator = isHookEnabled("tool-output-truncator") ? createToolOutputTruncatorHook(ctx, {
     experimental: pluginConfig.experimental
   }) : null;
-  const directoryAgentsInjector = isHookEnabled("directory-agents-injector") ? createDirectoryAgentsInjectorHook(ctx) : null;
+  let directoryAgentsInjector = null;
+  if (isHookEnabled("directory-agents-injector")) {
+    const currentVersion = getOpenCodeVersion();
+    const hasNativeSupport = currentVersion !== null && isOpenCodeVersionAtLeast(OPENCODE_NATIVE_AGENTS_INJECTION_VERSION);
+    if (hasNativeSupport) {
+      console.warn(`[oh-my-opencode] directory-agents-injector hook auto-disabled: ` + `OpenCode ${currentVersion} has native AGENTS.md support (>= ${OPENCODE_NATIVE_AGENTS_INJECTION_VERSION})`);
+      log("directory-agents-injector auto-disabled due to native OpenCode support", {
+        currentVersion,
+        nativeVersion: OPENCODE_NATIVE_AGENTS_INJECTION_VERSION
+      });
+    } else {
+      directoryAgentsInjector = createDirectoryAgentsInjectorHook(ctx);
+    }
+  }
   const directoryReadmeInjector = isHookEnabled("directory-readme-injector") ? createDirectoryReadmeInjectorHook(ctx) : null;
   const emptyTaskResponseDetector = isHookEnabled("empty-task-response-detector") ? createEmptyTaskResponseDetectorHook(ctx) : null;
   const thinkMode = isHookEnabled("think-mode") ? createThinkModeHook() : null;
@@ -56453,13 +56730,20 @@ var OhMyOpenCodePlugin = async (ctx) => {
       }
       const message = output.message;
       if (firstMessageVariantGate.shouldOverride(input.sessionID)) {
-        const variant = resolveAgentVariant(pluginConfig, input.agent);
+        const variant = input.model && input.agent ? resolveVariantForModel(pluginConfig, input.agent, input.model) : resolveAgentVariant(pluginConfig, input.agent);
         if (variant !== undefined) {
           message.variant = variant;
         }
         firstMessageVariantGate.markApplied(input.sessionID);
       } else {
-        applyAgentVariant(pluginConfig, input.agent, message);
+        if (input.model && input.agent && message.variant === undefined) {
+          const variant = resolveVariantForModel(pluginConfig, input.agent, input.model);
+          if (variant !== undefined) {
+            message.variant = variant;
+          }
+        } else {
+          applyAgentVariant(pluginConfig, input.agent, message);
+        }
       }
       await keywordDetector?.["chat.message"]?.(input, output);
       await claudeCodeHooks["chat.message"]?.(input, output);
@@ -56636,6 +56920,9 @@ var OhMyOpenCodePlugin = async (ctx) => {
       }
     },
     "tool.execute.after": async (input, output) => {
+      if (!output) {
+        return;
+      }
       await claudeCodeHooks["tool.execute.after"](input, output);
       await toolOutputTruncator?.["tool.execute.after"](input, output);
       await contextWindowMonitor?.["tool.execute.after"](input, output);