oh-my-opencode-slim 0.7.0 → 0.8.1

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;
 }
 
@@ -3338,6 +3367,14 @@ var SUBAGENT_NAMES = [
 ];
 var ORCHESTRATOR_NAME = "orchestrator";
 var ALL_AGENT_NAMES = [ORCHESTRATOR_NAME, ...SUBAGENT_NAMES];
+var SUBAGENT_DELEGATION_RULES = {
+  orchestrator: SUBAGENT_NAMES,
+  fixer: [],
+  designer: [],
+  explorer: [],
+  librarian: [],
+  oracle: []
+};
 var DEFAULT_MODELS = {
   orchestrator: "kimi-for-coding/k2p5",
   oracle: "openai/gpt-5.2-codex",
@@ -16939,6 +16976,34 @@ function date4(params) {
 // node_modules/zod/v4/classic/external.js
 config(en_default());
 // src/config/schema.ts
+var ProviderModelIdSchema = exports_external.string().regex(/^[^/\s]+\/[^\s]+$/, "Expected provider/model format (provider/.../model)");
+var ManualAgentPlanSchema = exports_external.object({
+  primary: ProviderModelIdSchema,
+  fallback1: ProviderModelIdSchema,
+  fallback2: ProviderModelIdSchema,
+  fallback3: ProviderModelIdSchema
+}).superRefine((value, ctx) => {
+  const unique = new Set([
+    value.primary,
+    value.fallback1,
+    value.fallback2,
+    value.fallback3
+  ]);
+  if (unique.size !== 4) {
+    ctx.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      message: "primary and fallbacks must be unique per agent"
+    });
+  }
+});
+var ManualPlanSchema = exports_external.object({
+  orchestrator: ManualAgentPlanSchema,
+  oracle: ManualAgentPlanSchema,
+  designer: ManualAgentPlanSchema,
+  explorer: ManualAgentPlanSchema,
+  librarian: ManualAgentPlanSchema,
+  fixer: ManualAgentPlanSchema
+}).strict();
 var AgentModelChainSchema = exports_external.array(exports_external.string()).min(1);
 var FallbackChainsSchema = exports_external.object({
   orchestrator: AgentModelChainSchema.optional(),
@@ -16947,7 +17012,7 @@ var FallbackChainsSchema = exports_external.object({
   explorer: AgentModelChainSchema.optional(),
   librarian: AgentModelChainSchema.optional(),
   fixer: AgentModelChainSchema.optional()
-}).strict();
+}).catchall(AgentModelChainSchema);
 var AgentOverrideConfigSchema = exports_external.object({
   model: exports_external.string().optional(),
   temperature: exports_external.number().min(0).max(2).optional(),
@@ -16974,11 +17039,14 @@ 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({
   preset: exports_external.string().optional(),
+  scoringEngineVersion: exports_external.enum(["v1", "v2-shadow", "v2"]).optional(),
+  balanceProviderUsage: exports_external.boolean().optional(),
+  manualPlan: ManualPlanSchema.optional(),
   presets: exports_external.record(exports_external.string(), PresetSchema).optional(),
   agents: exports_external.record(exports_external.string(), AgentOverrideConfigSchema).optional(),
   disabled_mcps: exports_external.array(exports_external.string()).optional(),
@@ -17241,9 +17309,10 @@ var FIXER_PROMPT = `You are Fixer - a fast, focused implementation specialist.
 
 **Constraints**:
 - NO external research (no websearch, context7, grep_app)
-- NO delegation (no background_task)
+- NO delegation (no background_task, no spawning subagents)
 - No multi-step research/planning; minimal execution sequence ok
-- If context is insufficient, read the files listed; only ask for missing inputs you cannot retrieve
+- If context is insufficient: use grep/glob/lsp_diagnostics directly \u2014 do not delegate
+- Only ask for missing inputs you truly cannot retrieve yourself
 
 **Output Format**:
 <summary>
@@ -17430,7 +17499,7 @@ Each specialist delivers 10x results in their domain:
 - @explorer \u2192 Parallel discovery when you need to find unknowns, not read knowns
 - @librarian \u2192 Complex/evolving APIs where docs prevent errors, not basic usage
 - @oracle \u2192 High-stakes decisions where wrong choice is costly, not routine calls
-- @designer \u2192 User-facing experiences where polish matters, not internal logic  
+- @designer \u2192 User-facing experiences where polish matters, not internal logic
 - @fixer \u2192 Parallel execution of clear specs, not explaining trivial changes
 
 **Delegation efficiency:**
@@ -17465,6 +17534,10 @@ Balance: respect dependencies, avoid parallelizing what must be sequential.
 - Confirm specialists completed successfully
 - Verify solution meets requirements
 
+## Agent Role Mapping
+When a workflow calls for an **implementer** subagent: dispatch \`@fixer\`. Fixer has enforced constraints (no research, no delegation, structured output) that match the implementer role exactly.
+When a workflow calls for a **reviewer** subagent: dispatch \`@oracle\`. Oracle has the depth for architectural review and access to code review skills.
+
 </Workflow>
 
 <Communication>
@@ -17522,6 +17595,8 @@ ${customAppendPrompt}`;
 function applyOverrides(agent, override) {
   if (override.model)
     agent.config.model = override.model;
+  if (override.variant)
+    agent.config.variant = override.variant;
   if (override.temperature !== undefined)
     agent.config.temperature = override.temperature;
 }
@@ -17829,6 +17904,16 @@ async function closeTmuxPane(paneId) {
     return false;
   }
   try {
+    log("[tmux] closeTmuxPane: sending Ctrl+C for graceful shutdown", {
+      paneId
+    });
+    const ctrlCProc = spawn([tmux, "send-keys", "-t", paneId, "C-c"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    await ctrlCProc.exited;
+    await new Promise((r) => setTimeout(r, 250));
+    log("[tmux] closeTmuxPane: killing pane", { paneId });
     const proc = spawn([tmux, "kill-pane", "-t", paneId], {
       stdout: "pipe",
       stderr: "pipe"
@@ -17959,6 +18044,7 @@ function generateTaskId() {
 class BackgroundTaskManager {
   tasks = new Map;
   tasksBySessionId = new Map;
+  agentBySessionId = new Map;
   client;
   directory;
   tmuxEnabled;
@@ -17978,6 +18064,20 @@ class BackgroundTaskManager {
     };
     this.maxConcurrentStarts = this.backgroundConfig.maxConcurrentStarts;
   }
+  getSubagentRules(agentName) {
+    return SUBAGENT_DELEGATION_RULES[agentName] ?? ["explorer"];
+  }
+  isAgentAllowed(parentSessionId, requestedAgent) {
+    const parentAgentName = this.agentBySessionId.get(parentSessionId) ?? "orchestrator";
+    const allowedSubagents = this.getSubagentRules(parentAgentName);
+    if (allowedSubagents.length === 0)
+      return false;
+    return allowedSubagents.includes(requestedAgent);
+  }
+  getAllowedSubagents(parentSessionId) {
+    const parentAgentName = this.agentBySessionId.get(parentSessionId) ?? "orchestrator";
+    return this.getSubagentRules(parentAgentName);
+  }
   launch(opts) {
     const task = {
       id: generateTaskId(),
@@ -18028,6 +18128,10 @@ class BackgroundTaskManager {
     return chain;
   }
   async promptWithTimeout(args, timeoutMs) {
+    if (timeoutMs <= 0) {
+      await this.client.session.prompt(args);
+      return;
+    }
     await Promise.race([
       this.client.session.prompt(args),
       new Promise((_, reject) => {
@@ -18037,6 +18141,13 @@ class BackgroundTaskManager {
       })
     ]);
   }
+  calculateToolPermissions(agentName) {
+    const allowedSubagents = this.getSubagentRules(agentName);
+    if (allowedSubagents.length === 0) {
+      return { background_task: false, task: false };
+    }
+    return { background_task: true, task: true };
+  }
   async startTask(task) {
     task.status = "starting";
     this.activeStarts++;
@@ -18057,19 +18168,21 @@ class BackgroundTaskManager {
       }
       task.sessionId = session.data.id;
       this.tasksBySessionId.set(session.data.id, task.id);
+      this.agentBySessionId.set(session.data.id, task.agent);
       task.status = "running";
       if (this.tmuxEnabled) {
         await new Promise((r) => setTimeout(r, 500));
       }
+      const toolPermissions = this.calculateToolPermissions(task.agent);
       const promptQuery = { directory: this.directory };
       const resolvedVariant = resolveAgentVariant(this.config, task.agent);
       const basePromptBody = applyAgentVariant(resolvedVariant, {
         agent: task.agent,
-        tools: { background_task: false, task: false },
+        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 = [];
@@ -18133,6 +18246,33 @@ class BackgroundTaskManager {
       await this.extractAndCompleteTask(task);
     }
   }
+  async handleSessionDeleted(event) {
+    if (event.type !== "session.deleted")
+      return;
+    const sessionId = event.properties?.info?.id ?? event.properties?.sessionID;
+    if (!sessionId)
+      return;
+    const taskId = this.tasksBySessionId.get(sessionId);
+    if (!taskId)
+      return;
+    const task = this.tasks.get(taskId);
+    if (!task)
+      return;
+    if (task.status === "running" || task.status === "pending") {
+      log(`[background-manager] Session deleted, cancelling task: ${task.id}`);
+      task.status = "cancelled";
+      task.completedAt = new Date;
+      task.error = "Session deleted";
+      this.tasksBySessionId.delete(sessionId);
+      this.agentBySessionId.delete(sessionId);
+      const resolver = this.completionResolvers.get(taskId);
+      if (resolver) {
+        resolver(task);
+        this.completionResolvers.delete(taskId);
+      }
+      log(`[background-manager] Task cancelled due to session deletion: ${task.id}`);
+    }
+  }
   async extractAndCompleteTask(task) {
     if (!task.sessionId)
       return;
@@ -18175,6 +18315,12 @@ class BackgroundTaskManager {
     }
     if (task.sessionId) {
       this.tasksBySessionId.delete(task.sessionId);
+      this.agentBySessionId.delete(task.sessionId);
+    }
+    if (task.sessionId) {
+      this.client.session.abort({
+        path: { id: task.sessionId }
+      }).catch(() => {});
     }
     if (task.parentSessionId) {
       this.sendCompletionNotification(task).catch((err) => {
@@ -18261,6 +18407,7 @@ class BackgroundTaskManager {
     this.completionResolvers.clear();
     this.tasks.clear();
     this.tasksBySessionId.clear();
+    this.agentBySessionId.clear();
   }
 }
 // src/background/tmux-session-manager.ts
@@ -18342,6 +18489,19 @@ class TmuxSessionManager {
       await this.closeSession(sessionId);
     }
   }
+  async onSessionDeleted(event) {
+    if (!this.enabled)
+      return;
+    if (event.type !== "session.deleted")
+      return;
+    const sessionId = event.properties?.sessionID;
+    if (!sessionId)
+      return;
+    log("[tmux-session-manager] session deleted, closing pane", {
+      sessionId
+    });
+    await this.closeSession(sessionId);
+  }
   startPolling() {
     if (this.pollInterval)
       return;
@@ -18420,6 +18580,8 @@ class TmuxSessionManager {
 // src/hooks/auto-update-checker/cache.ts
 import * as fs3 from "fs";
 import * as path4 from "path";
+// src/cli/dynamic-model-selection.ts
+var FREE_BIASED_PROVIDERS = new Set(["opencode"]);
 // src/hooks/auto-update-checker/constants.ts
 import * as os3 from "os";
 import * as path3 from "path";
@@ -18809,10 +18971,169 @@ function showToast(ctx, title, message, variant = "info", duration3 = 3000) {
     body: { title, message, variant, duration: duration3 }
   }).catch(() => {});
 }
+// src/hooks/delegate-task-retry/patterns.ts
+var DELEGATE_TASK_ERROR_PATTERNS = [
+  {
+    pattern: "run_in_background",
+    errorType: "missing_run_in_background",
+    fixHint: "Add run_in_background=false (delegation) or run_in_background=true (parallel exploration)."
+  },
+  {
+    pattern: "load_skills",
+    errorType: "missing_load_skills",
+    fixHint: "Add load_skills=[] (empty array when no skill is needed)."
+  },
+  {
+    pattern: "category OR subagent_type",
+    errorType: "mutual_exclusion",
+    fixHint: 'Provide only one: category (e.g., "unspecified-low") OR subagent_type (e.g., "explorer").'
+  },
+  {
+    pattern: "Must provide either category or subagent_type",
+    errorType: "missing_category_or_agent",
+    fixHint: 'Add either category="unspecified-low" or subagent_type="explorer".'
+  },
+  {
+    pattern: "Unknown category",
+    errorType: "unknown_category",
+    fixHint: "Use a valid category listed in the error output."
+  },
+  {
+    pattern: "Unknown agent",
+    errorType: "unknown_agent",
+    fixHint: "Use a valid agent name from the available list."
+  },
+  {
+    pattern: "Skills not found",
+    errorType: "unknown_skills",
+    fixHint: "Use valid skill names listed in the error output."
+  },
+  {
+    pattern: "is not allowed. Allowed agents:",
+    errorType: "background_agent_not_allowed",
+    fixHint: "Use one of the allowed agents shown in the error or delegate from a parent agent that can call this subagent."
+  }
+];
+function detectDelegateTaskError(output) {
+  if (!output || typeof output !== "string")
+    return null;
+  const hasErrorSignal = output.includes("[ERROR]") || output.includes("Invalid arguments") || output.includes("is not allowed. Allowed agents:");
+  if (!hasErrorSignal)
+    return null;
+  for (const pattern of DELEGATE_TASK_ERROR_PATTERNS) {
+    if (output.includes(pattern.pattern)) {
+      return {
+        errorType: pattern.errorType,
+        originalOutput: output
+      };
+    }
+  }
+  return null;
+}
+// src/hooks/delegate-task-retry/guidance.ts
+function extractAvailableList(output) {
+  const match = output.match(/Allowed agents:\s*(.+)$/m);
+  if (match)
+    return match[1].trim();
+  const available = output.match(/Available[^:]*:\s*(.+)$/m);
+  if (available)
+    return available[1].trim();
+  return null;
+}
+function buildRetryGuidance(errorInfo) {
+  const pattern = DELEGATE_TASK_ERROR_PATTERNS.find((p) => p.errorType === errorInfo.errorType);
+  if (!pattern) {
+    return `
+[delegate-task retry] Fix parameters and retry with corrected arguments.`;
+  }
+  const available = extractAvailableList(errorInfo.originalOutput);
+  const lines = [
+    "",
+    "[delegate-task retry suggestion]",
+    `Error type: ${errorInfo.errorType}`,
+    `Fix: ${pattern.fixHint}`
+  ];
+  if (available) {
+    lines.push(`Available: ${available}`);
+  }
+  lines.push("Retry now with corrected parameters. Example:", 'task(description="...", prompt="...", category="unspecified-low", run_in_background=false, load_skills=[])');
+  return lines.join(`
+`);
+}
+// src/hooks/delegate-task-retry/hook.ts
+function createDelegateTaskRetryHook(_ctx) {
+  return {
+    "tool.execute.after": async (input, output) => {
+      const toolName = input.tool.toLowerCase();
+      const isDelegateTool = toolName === "task" || toolName === "background_task";
+      if (!isDelegateTool)
+        return;
+      if (typeof output.output !== "string")
+        return;
+      const detected = detectDelegateTaskError(output.output);
+      if (!detected)
+        return;
+      output.output += `
+${buildRetryGuidance(detected)}`;
+    }
+  };
+}
+// src/hooks/json-error-recovery/hook.ts
+var JSON_ERROR_TOOL_EXCLUDE_LIST = [
+  "bash",
+  "read",
+  "glob",
+  "grep",
+  "webfetch",
+  "grep_app_searchgithub",
+  "websearch_web_search_exa"
+];
+var JSON_ERROR_PATTERNS = [
+  /json parse error/i,
+  /failed to parse json/i,
+  /invalid json/i,
+  /malformed json/i,
+  /unexpected end of json input/i,
+  /syntaxerror:\s*unexpected token.*json/i,
+  /json[^\n]*expected '\}'/i,
+  /json[^\n]*unexpected eof/i
+];
+var JSON_ERROR_REMINDER_MARKER = "[JSON PARSE ERROR - IMMEDIATE ACTION REQUIRED]";
+var JSON_ERROR_EXCLUDED_TOOLS = new Set(JSON_ERROR_TOOL_EXCLUDE_LIST);
+var JSON_ERROR_REMINDER = `
+[JSON PARSE ERROR - IMMEDIATE ACTION REQUIRED]
+
+You sent invalid JSON arguments. The system could not parse your tool call.
+STOP and do this NOW:
+
+1. LOOK at the error message above to see what was expected vs what you sent.
+2. CORRECT your JSON syntax (missing braces, unescaped quotes, trailing commas, etc).
+3. RETRY the tool call with valid JSON.
+
+DO NOT repeat the exact same invalid call.
+`;
+function createJsonErrorRecoveryHook(_ctx) {
+  return {
+    "tool.execute.after": async (input, output) => {
+      if (JSON_ERROR_EXCLUDED_TOOLS.has(input.tool.toLowerCase()))
+        return;
+      if (typeof output.output !== "string")
+        return;
+      if (output.output.includes(JSON_ERROR_REMINDER_MARKER))
+        return;
+      const outputText = output.output;
+      const hasJsonError = JSON_ERROR_PATTERNS.some((pattern) => pattern.test(outputText));
+      if (hasJsonError) {
+        output.output += `
+${JSON_ERROR_REMINDER}`;
+      }
+    }
+  };
+}
 // src/hooks/phase-reminder/index.ts
-var PHASE_REMINDER = `<reminder>\u26A0\uFE0F MANDATORY: Understand\u2192DELEGATE(! based on each agent rules)\u2192Split-and-Parallelize(?)\u2192Plan\u2192Execute\u2192Verify
-Available Specialist: @oracle @librarian @explorer @designer @fixer
-</reminder>`;
+var PHASE_REMINDER = `<reminder>Recall Workflow Rules:
+Understand \u2192 find the best path (delegate based on rules and parallelize independent work) \u2192 execute \u2192 verify.
+If delegating, launch the specialist in the same turn you mention it.</reminder>`;
 function createPhaseReminderHook() {
   return {
     "experimental.chat.messages.transform": async (_input, output) => {
@@ -18852,7 +19173,7 @@ ${originalText}`;
 var NUDGE = `
 
 ---
-Reminder to follow the workflow instructions, consider delegation to specialist(s)`;
+Workflow Reminder: delegate based on rules; If mentioning a specialist, launch it in this same turn.`;
 function createPostReadNudgeHook() {
   return {
     "tool.execute.after": async (input, output) => {
@@ -31789,11 +32110,16 @@ Key behaviors:
       const agent = String(args.agent);
       const prompt = String(args.prompt);
       const description = String(args.description);
+      const parentSessionId = toolContext.sessionID;
+      if (!manager.isAgentAllowed(parentSessionId, agent)) {
+        const allowed = manager.getAllowedSubagents(parentSessionId);
+        return `Agent '${agent}' is not allowed. Allowed agents: ${allowed.join(", ")}`;
+      }
       const task = manager.launch({
         agent,
         prompt,
         description,
-        parentSessionId: toolContext.sessionID
+        parentSessionId
       });
       return `Background task launched.
 
@@ -32164,11 +32490,14 @@ ${summary}`);
 
 // src/tools/grep/tools.ts
 var grep = tool({
-  description: "Fast content search tool with safety limits (60s timeout, 10MB output). " + "Searches file contents using regular expressions. " + 'Supports full regex syntax (eg. "log.*Error", "function\\s+\\w+", etc.). ' + 'Filter files by pattern with the include parameter (eg. "*.js", "*.{ts,tsx}"). ' + "Returns file paths with matches sorted by modification time.",
+  description: "Fast content search tool with safety limits (60s timeout, 10MB output). " + "Searches file contents using regular expressions. " + 'Supports full regex syntax (eg. "log.*Error", "function\\s+\\w+", etc.). ' + 'Filter files by pattern with the include parameter (e.g. "*.js", "*.{ts,tsx}"). ' + "Returns file paths with matches sorted by modification time.",
   args: {
     pattern: tool.schema.string().describe("The regex pattern to search for in file contents"),
     include: tool.schema.string().optional().describe('File pattern to include in the search (e.g. "*.js", "*.{ts,tsx}")'),
-    path: tool.schema.string().optional().describe("The directory to search in. Defaults to the current working directory.")
+    path: tool.schema.string().optional().describe("The directory to search in. Defaults to the current working directory."),
+    caseSensitive: tool.schema.boolean().optional().default(false).describe("Perform case-sensitive search (default: false)"),
+    wholeWord: tool.schema.boolean().optional().default(false).describe("Match whole words only (default: false)"),
+    fixedStrings: tool.schema.boolean().optional().default(false).describe("Treat pattern as literal string (default: false)")
   },
   execute: async (args) => {
     try {
@@ -32178,7 +32507,10 @@ var grep = tool({
         pattern: args.pattern,
         paths: paths2,
         globs,
-        context: 0
+        context: 0,
+        caseSensitive: args.caseSensitive ?? false,
+        wholeWord: args.wholeWord ?? false,
+        fixedStrings: args.fixedStrings ?? false
       });
       return formatGrepResult(result);
     } catch (e) {
@@ -33107,6 +33439,8 @@ var OhMyOpenCodeLite = async (ctx) => {
   });
   const phaseReminderHook = createPhaseReminderHook();
   const postReadNudgeHook = createPostReadNudgeHook();
+  const delegateTaskRetryHook = createDelegateTaskRetryHook(ctx);
+  const jsonErrorRecoveryHook = createJsonErrorRecoveryHook(ctx);
   return {
     name: "oh-my-opencode-slim",
     agent: agents,
@@ -33162,9 +33496,15 @@ var OhMyOpenCodeLite = async (ctx) => {
       await tmuxSessionManager.onSessionCreated(input.event);
       await backgroundManager.handleSessionStatus(input.event);
       await tmuxSessionManager.onSessionStatus(input.event);
+      await backgroundManager.handleSessionDeleted(input.event);
+      await tmuxSessionManager.onSessionDeleted(input.event);
     },
     "experimental.chat.messages.transform": phaseReminderHook["experimental.chat.messages.transform"],
-    "tool.execute.after": postReadNudgeHook["tool.execute.after"]
+    "tool.execute.after": async (input, output) => {
+      await delegateTaskRetryHook["tool.execute.after"](input, output);
+      await jsonErrorRecoveryHook["tool.execute.after"](input, output);
+      await postReadNudgeHook["tool.execute.after"](input, output);
+    }
   };
 };
 var src_default = OhMyOpenCodeLite;

package/dist/utils/env.d.ts

@@ -0,0 +1 @@
+export declare function getEnv(name: string): string | undefined;

package/dist/utils/index.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode-slim",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "description": "Lightweight agent orchestration plugin for OpenCode - a slimmed-down fork of oh-my-opencode",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -50,17 +50,17 @@
   },
   "dependencies": {
     "@ast-grep/cli": "^0.40.0",
-    "@modelcontextprotocol/sdk": "^1.25.1",
-    "@opencode-ai/plugin": "^1.1.19",
-    "@opencode-ai/sdk": "^1.1.19",
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "@opencode-ai/plugin": "^1.2.6",
+    "@opencode-ai/sdk": "^1.2.6",
     "vscode-jsonrpc": "^8.2.0",
     "vscode-languageserver-protocol": "^3.17.5",
-    "zod": "^4.1.8"
+    "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.3.11",
-    "bun-types": "latest",
-    "typescript": "^5.7.3"
+    "@biomejs/biome": "2.4.2",
+    "bun-types": "1.3.9",
+    "typescript": "^5.9.3"
   },
   "trustedDependencies": [
     "@ast-grep/cli"