oh-my-opencode-slim 1.0.6 → 1.1.0

package/dist/index.js

@@ -6246,33 +6246,33 @@ var require_URL = __commonJS((exports, module) => {
         else
           return basepath.substring(0, lastslash + 1) + refpath;
       }
-      function remove_dot_segments(path15) {
-        if (!path15)
-          return path15;
+      function remove_dot_segments(path16) {
+        if (!path16)
+          return path16;
         var output = "";
-        while (path15.length > 0) {
-          if (path15 === "." || path15 === "..") {
-            path15 = "";
+        while (path16.length > 0) {
+          if (path16 === "." || path16 === "..") {
+            path16 = "";
             break;
           }
-          var twochars = path15.substring(0, 2);
-          var threechars = path15.substring(0, 3);
-          var fourchars = path15.substring(0, 4);
+          var twochars = path16.substring(0, 2);
+          var threechars = path16.substring(0, 3);
+          var fourchars = path16.substring(0, 4);
           if (threechars === "../") {
-            path15 = path15.substring(3);
+            path16 = path16.substring(3);
           } else if (twochars === "./") {
-            path15 = path15.substring(2);
+            path16 = path16.substring(2);
           } else if (threechars === "/./") {
-            path15 = "/" + path15.substring(3);
-          } else if (twochars === "/." && path15.length === 2) {
-            path15 = "/";
-          } else if (fourchars === "/../" || threechars === "/.." && path15.length === 3) {
-            path15 = "/" + path15.substring(4);
+            path16 = "/" + path16.substring(3);
+          } else if (twochars === "/." && path16.length === 2) {
+            path16 = "/";
+          } else if (fourchars === "/../" || threechars === "/.." && path16.length === 3) {
+            path16 = "/" + path16.substring(4);
             output = output.replace(/\/?[^\/]*$/, "");
           } else {
-            var segment = path15.match(/(\/?([^\/]*))/)[0];
+            var segment = path16.match(/(\/?([^\/]*))/)[0];
             output += segment;
-            path15 = path15.substring(segment.length);
+            path16 = path16.substring(segment.length);
           }
         }
         return output;
@@ -18220,6 +18220,12 @@ var CUSTOM_SKILLS = [
     description: "Repository understanding and hierarchical codemap generation",
     allowedAgents: ["orchestrator"],
     sourcePath: "src/skills/codemap"
+  },
+  {
+    name: "clonedeps",
+    description: "Clone important dependency source for local inspection",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/clonedeps"
   }
 ];
 
@@ -18393,6 +18399,56 @@ var CouncilConfigSchema = z.object({
 import * as fs from "node:fs";
 import * as path from "node:path";
 
+// src/utils/compat.ts
+import { spawn as nodeSpawn } from "node:child_process";
+import { writeFile as fsWriteFile } from "node:fs/promises";
+var isBun = typeof globalThis.Bun !== "undefined";
+function collectStream(stream) {
+  if (!stream)
+    return () => Promise.resolve("");
+  const chunks = [];
+  stream.on("data", (chunk) => chunks.push(chunk));
+  return () => new Promise((resolve, reject) => {
+    if (!stream.readable) {
+      resolve(Buffer.concat(chunks).toString("utf-8"));
+      return;
+    }
+    stream.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+    stream.on("error", reject);
+  });
+}
+function crossSpawn(command, options) {
+  const [cmd, ...args] = command;
+  const proc = nodeSpawn(cmd, args, {
+    stdio: [
+      options?.stdin ?? "ignore",
+      options?.stdout ?? "pipe",
+      options?.stderr ?? "pipe"
+    ],
+    cwd: options?.cwd,
+    env: options?.env
+  });
+  const stdoutCollector = collectStream(proc.stdout);
+  const stderrCollector = collectStream(proc.stderr);
+  const exited = new Promise((resolve, reject) => {
+    proc.on("error", reject);
+    proc.on("close", (code) => resolve(code ?? 1));
+  });
+  return {
+    proc,
+    stdout: stdoutCollector,
+    stderr: stderrCollector,
+    exited,
+    kill: (signal) => proc.kill(signal),
+    get exitCode() {
+      return proc.exitCode;
+    }
+  };
+}
+async function crossWrite(path, data) {
+  await fsWriteFile(path, Buffer.from(data));
+}
+
 // src/config/agent-mcps.ts
 var DEFAULT_AGENT_MCPS = {
   orchestrator: ["*", "!context7"],
@@ -18530,6 +18586,17 @@ var SessionManagerConfigSchema = z2.object({
   readContextMinLines: z2.number().int().min(0).max(1000).default(10),
   readContextMaxFiles: z2.number().int().min(0).max(50).default(8)
 });
+var DivoomConfigSchema = z2.object({
+  enabled: z2.boolean().default(false),
+  python: z2.string().min(1).default("/Applications/Divoom MiniToo.app/Contents/Resources/.venv/bin/python"),
+  script: z2.string().min(1).default("/Applications/Divoom MiniToo.app/Contents/Resources/tools/divoom_send.py"),
+  size: z2.number().int().min(1).max(1024).default(128),
+  fps: z2.number().int().min(1).max(60).default(8),
+  speed: z2.number().int().min(1).max(1e4).default(125),
+  maxFrames: z2.number().int().min(1).max(500).default(24),
+  posterizeBits: z2.number().int().min(1).max(8).default(3),
+  gifs: z2.record(z2.string(), z2.string().min(1)).optional()
+});
 var TodoContinuationConfigSchema = z2.object({
   maxContinuations: z2.number().int().min(1).max(50).default(5).describe("Maximum consecutive auto-continuations before stopping to ask user"),
   cooldownMs: z2.number().int().min(0).max(30000).default(3000).describe("Delay in ms before auto-continuing (gives user time to abort)"),
@@ -18581,6 +18648,7 @@ var PluginConfigSchema = z2.object({
   websearch: WebsearchConfigSchema.optional(),
   interview: InterviewConfigSchema.optional(),
   sessionManager: SessionManagerConfigSchema.optional(),
+  divoom: DivoomConfigSchema.optional(),
   todoContinuation: TodoContinuationConfigSchema.optional(),
   fallback: FailoverConfigSchema.optional(),
   council: CouncilConfigSchema.optional()
@@ -18597,20 +18665,49 @@ var PluginConfigSchema = z2.object({
 
 // src/config/loader.ts
 var PROMPTS_DIR_NAME = "oh-my-opencode-slim";
-function loadConfigFromPath(configPath) {
+function loadConfigFromPath(configPath, options) {
   try {
     const content = fs.readFileSync(configPath, "utf-8");
-    const rawConfig = JSON.parse(stripJsonComments(content));
+    let rawConfig;
+    try {
+      rawConfig = JSON.parse(stripJsonComments(content));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      options?.onWarning?.({
+        path: configPath,
+        kind: "invalid-json",
+        message
+      });
+      if (!options?.silent) {
+        console.warn(`[oh-my-opencode-slim] Invalid JSON in ${configPath}:`, message);
+      }
+      return null;
+    }
     const result = PluginConfigSchema.safeParse(rawConfig);
     if (!result.success) {
-      console.warn(`[oh-my-opencode-slim] Invalid config at ${configPath}:`);
-      console.warn(result.error.format());
+      options?.onWarning?.({
+        path: configPath,
+        kind: "invalid-schema",
+        message: "Config does not match schema",
+        formatted: result.error.format()
+      });
+      if (!options?.silent) {
+        console.warn(`[oh-my-opencode-slim] Invalid config at ${configPath}:`);
+        console.warn(result.error.format());
+      }
       return null;
     }
     return result.data;
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code !== "ENOENT") {
-      console.warn(`[oh-my-opencode-slim] Error reading config from ${configPath}:`, error.message);
+      options?.onWarning?.({
+        path: configPath,
+        kind: "read-error",
+        message: error.message
+      });
+      if (!options?.silent) {
+        console.warn(`[oh-my-opencode-slim] Error reading config from ${configPath}:`, error.message);
+      }
     }
     return null;
   }
@@ -18635,6 +18732,26 @@ function findConfigPathInDirs(configDirs, baseName) {
   }
   return null;
 }
+function findPluginConfigPaths(directory) {
+  const userConfigPath = findConfigPathInDirs(getConfigSearchDirs(), "oh-my-opencode-slim");
+  const projectConfigBasePath = path.join(directory, ".opencode", "oh-my-opencode-slim");
+  const projectConfigPath = findConfigPath(projectConfigBasePath);
+  return { userConfigPath, projectConfigPath };
+}
+function mergePluginConfigs(base, override) {
+  return {
+    ...base,
+    ...override,
+    agents: deepMerge(base.agents, override.agents),
+    tmux: deepMerge(base.tmux, override.tmux),
+    multiplexer: deepMerge(base.multiplexer, override.multiplexer),
+    interview: deepMerge(base.interview, override.interview),
+    sessionManager: deepMerge(base.sessionManager, override.sessionManager),
+    divoom: deepMerge(base.divoom, override.divoom),
+    fallback: deepMerge(base.fallback, override.fallback),
+    council: deepMerge(base.council, override.council)
+  };
+}
 function deepMerge(base, override) {
   if (!base)
     return override;
@@ -18652,24 +18769,12 @@ function deepMerge(base, override) {
   }
   return result;
 }
-function loadPluginConfig(directory) {
-  const userConfigPath = findConfigPathInDirs(getConfigSearchDirs(), "oh-my-opencode-slim");
-  const projectConfigBasePath = path.join(directory, ".opencode", "oh-my-opencode-slim");
-  const projectConfigPath = findConfigPath(projectConfigBasePath);
-  let config = userConfigPath ? loadConfigFromPath(userConfigPath) ?? {} : {};
-  const projectConfig = projectConfigPath ? loadConfigFromPath(projectConfigPath) : null;
+function loadPluginConfig(directory, options) {
+  const { userConfigPath, projectConfigPath } = findPluginConfigPaths(directory);
+  let config = userConfigPath ? loadConfigFromPath(userConfigPath, options) ?? {} : {};
+  const projectConfig = projectConfigPath ? loadConfigFromPath(projectConfigPath, options) : null;
   if (projectConfig) {
-    config = {
-      ...config,
-      ...projectConfig,
-      agents: deepMerge(config.agents, projectConfig.agents),
-      tmux: deepMerge(config.tmux, projectConfig.tmux),
-      multiplexer: deepMerge(config.multiplexer, projectConfig.multiplexer),
-      interview: deepMerge(config.interview, projectConfig.interview),
-      sessionManager: deepMerge(config.sessionManager, projectConfig.sessionManager),
-      fallback: deepMerge(config.fallback, projectConfig.fallback),
-      council: deepMerge(config.council, projectConfig.council)
-    };
+    config = mergePluginConfigs(config, projectConfig);
   }
   config = migrateTmuxToMultiplexer(config);
   const envPreset = process.env.OH_MY_OPENCODE_SLIM_PRESET;
@@ -18683,7 +18788,15 @@ function loadPluginConfig(directory) {
     } else {
       const presetSource = envPreset === config.preset ? "environment variable" : "config file";
       const availablePresets = config.presets ? Object.keys(config.presets).join(", ") : "none";
-      console.warn(`[oh-my-opencode-slim] Preset "${config.preset}" not found (from ${presetSource}). Available presets: ${availablePresets}`);
+      const message = `Preset "${config.preset}" not found (from ${presetSource}). Available presets: ${availablePresets}`;
+      options?.onWarning?.({
+        path: projectConfigPath ?? userConfigPath ?? "",
+        kind: "missing-preset",
+        message
+      });
+      if (!options?.silent) {
+        console.warn(`[oh-my-opencode-slim] ${message}`);
+      }
     }
   }
   return config;
@@ -18744,6 +18857,34 @@ function getCustomAgentNames(config) {
   });
 }
 // src/utils/session.ts
+var SESSION_ABORT_TIMEOUT_MS = 1000;
+
+class OperationTimeoutError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OperationTimeoutError";
+  }
+}
+async function withTimeout(operation, timeoutMs, message) {
+  if (timeoutMs <= 0)
+    return operation;
+  let timer;
+  try {
+    return await Promise.race([
+      operation,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => {
+          reject(new OperationTimeoutError(message));
+        }, timeoutMs);
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function abortSessionWithTimeout(client, sessionId, timeoutMs = SESSION_ABORT_TIMEOUT_MS) {
+  await withTimeout(client.session.abort({ path: { id: sessionId } }), timeoutMs, `Session abort timed out after ${timeoutMs}ms`);
+}
 function shortModelLabel(model) {
   return model.split("/").pop() ?? model;
 }
@@ -18757,13 +18898,16 @@ function parseModelReference(model) {
     modelID: model.slice(slashIndex + 1)
   };
 }
-async function promptWithTimeout(client, args, timeoutMs) {
+async function promptWithTimeout(client, args, timeoutMs, signal) {
+  if (signal?.aborted)
+    throw new Error("Prompt cancelled");
   if (timeoutMs <= 0) {
     await client.session.prompt(args);
     return;
   }
   const sessionId = args.path.id;
   let timer;
+  let onAbort;
   try {
     const promptPromise = client.session.prompt(args);
     promptPromise.catch(() => {});
@@ -18771,19 +18915,38 @@ async function promptWithTimeout(client, args, timeoutMs) {
       promptPromise,
       new Promise((_, reject) => {
         timer = setTimeout(() => {
-          client.session.abort({ path: { id: sessionId } }).catch(() => {});
-          reject(new Error(`Prompt timed out after ${timeoutMs}ms`));
+          reject(new OperationTimeoutError(`Prompt timed out after ${timeoutMs}ms`));
         }, timeoutMs);
+      }),
+      new Promise((_, reject) => {
+        if (!signal)
+          return;
+        if (signal.aborted) {
+          reject(new Error("Prompt cancelled"));
+          return;
+        }
+        onAbort = () => reject(new Error("Prompt cancelled"));
+        signal.addEventListener("abort", onAbort, { once: true });
       })
     ]);
+  } catch (error) {
+    if (error instanceof OperationTimeoutError) {
+      try {
+        await abortSessionWithTimeout(client, sessionId);
+      } catch {}
+    }
+    throw error;
   } finally {
     clearTimeout(timer);
+    if (onAbort)
+      signal?.removeEventListener("abort", onAbort);
   }
 }
 async function extractSessionResult(client, sessionId, options) {
   const includeReasoning = options?.includeReasoning ?? true;
   const messagesResult = await client.session.messages({
-    path: { id: sessionId }
+    path: { id: sessionId },
+    ...options?.directory ? { query: { directory: options.directory } } : {}
   });
   const messages = messagesResult.data ?? [];
   const assistantMessages = messages.filter((m) => m.info?.role === "assistant");
@@ -18822,7 +18985,7 @@ var AGENT_DESCRIPTIONS = {
 - **Don't delegate when:** Know the path and need actual content • Need full file anyway • Single specific lookup • About to edit the file`,
   librarian: `@librarian
 - Role: Authoritative source for current library docs and API references
-- Permissions: None
+- Permissions: External docs/search MCPs; no file edits
 - Stats: 10x better finding up-to-date library docs than orchestrator, 1/2 cost of orchestrator
 - Capabilities: Fetches latest official docs, examples, API signatures, version-specific behavior via grep_app MCP
 - **Delegate when:** Libraries with frequent API changes (React, Next.js, AI SDKs) • Complex APIs needing official examples (ORMs, auth) • Version-specific behavior matters • Unfamiliar library • Edge cases or advanced features • Nuanced best practices
@@ -18939,6 +19102,25 @@ ${enabledParallelExamples}
 
 Balance: respect dependencies, avoid parallelizing what must be sequential.
 
+### Context Isolation
+If no specialist delegation is needed, consider \`subtask\` before doing
+context-heavy work directly.
+
+Ask whether the parent context needs the details or only the result. Use
+\`subtask\` when the work is bounded, context-heavy, and the parent only needs a
+compact outcome.
+
+Use \`subtask\` for focused investigation, bounded analysis, cleanup, or
+verification across files/logs/messages.
+
+Do not use \`subtask\` for tiny tasks, open-ended work, interactive decisions,
+work better handled by a named specialist, or cases where the parent must reason
+over the details.
+
+When calling \`subtask\`, give a self-contained prompt with objective,
+constraints, relevant context, deliverable, and validation. Pass only clearly
+relevant files. Wait for the summary, then integrate and verify it.
+
 ### OpenCode subagent execution model
 - A delegated specialist runs in a separate child session.
 - Delegation is blocking for the parent at that point: send work out, then continue that line after results return.
@@ -19207,7 +19389,8 @@ function createCouncillorAgent(model, customPrompt, customAppendPrompt) {
         grep: "allow",
         lsp: "allow",
         list: "allow",
-        codesearch: "allow"
+        codesearch: "allow",
+        ast_grep_search: "allow"
       }
     }
   };
@@ -19529,10 +19712,14 @@ ${customAppendPrompt}`;
 
 // src/agents/index.ts
 var COUNCIL_TOOL_ALLOWED_AGENTS = new Set(["council"]);
+var SAFE_AGENT_ALIAS_RE = /^[a-z][a-z0-9_-]*$/i;
 function normalizeDisplayName(displayName) {
   const trimmed = displayName.trim();
   return trimmed.startsWith("@") ? trimmed.slice(1) : trimmed;
 }
+function isSafeDisplayName(displayName) {
+  return SAFE_AGENT_ALIAS_RE.test(displayName);
+}
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -19566,7 +19753,7 @@ function normalizeCustomAgentName(name) {
   return name.trim();
 }
 function isSafeCustomAgentName(name) {
-  return /^[a-z][a-z0-9_-]*$/i.test(name) && !isKnownAgentName(name);
+  return SAFE_AGENT_ALIAS_RE.test(name) && !isKnownAgentName(name);
 }
 function hasCustomAgentModel(override) {
   if (!override?.model) {
@@ -19626,6 +19813,9 @@ var SUBAGENT_FACTORIES = {
 };
 function createAgents(config) {
   const disabled = getDisabledAgents(config);
+  if (!config?.council) {
+    disabled.add("council");
+  }
   const getModelForAgent = (name) => {
     if (name === "fixer" && !getAgentOverride(config, "fixer")?.model) {
       const librarianOverride = getAgentOverride(config, "librarian")?.model;
@@ -19712,6 +19902,9 @@ function createAgents(config) {
   const usedDisplayNames = new Set;
   for (const [, displayName] of displayNameMap) {
     const normalizedDisplayName = normalizeDisplayName(displayName);
+    if (!isSafeDisplayName(normalizedDisplayName)) {
+      throw new Error(`displayName '${normalizedDisplayName}' must match /^[a-z][a-z0-9_-]*$/i`);
+    }
     if (usedDisplayNames.has(normalizedDisplayName)) {
       throw new Error(`Duplicate displayName '${normalizedDisplayName}' assigned to multiple agents`);
     }
@@ -20138,6 +20331,286 @@ class CouncilManager {
     };
   }
 }
+// src/divoom/manager.ts
+import { spawn } from "node:child_process";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2 } from "node:fs";
+import * as os2 from "node:os";
+import path3 from "node:path";
+import { fileURLToPath } from "node:url";
+var AGENT_GIFS = {
+  council: "council.gif",
+  councillor: "council.gif",
+  designer: "designer.gif",
+  explorer: "explorer.gif",
+  fixer: "fixer.gif",
+  input: "input.gif",
+  intro: "intro.gif",
+  librarian: "librarian.gif",
+  oracle: "oracle.gif",
+  orchestrator: "orchestrator.gif"
+};
+var DEFAULT_DIVOOM_CONFIG = {
+  enabled: false,
+  python: "/Applications/Divoom MiniToo.app/Contents/Resources/.venv/bin/python",
+  script: "/Applications/Divoom MiniToo.app/Contents/Resources/tools/divoom_send.py",
+  size: 128,
+  fps: 8,
+  speed: 125,
+  maxFrames: 24,
+  posterizeBits: 3
+};
+var DIVOOM_ENABLE_ENV = "OH_MY_OPENCODE_SLIM_DIVOOM";
+function resolveAssetDir() {
+  const moduleDir = path3.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    moduleDir,
+    path3.resolve(moduleDir, "divoom"),
+    path3.resolve(moduleDir, "../../src/divoom"),
+    path3.resolve(process.cwd(), "src/divoom")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync2(path3.join(candidate, "intro.gif"))) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function normalizeAgentName(value) {
+  if (typeof value !== "string")
+    return null;
+  const normalized = value.trim().toLowerCase();
+  return normalized.length > 0 ? normalized : null;
+}
+function isEnvEnabled(value) {
+  if (!value)
+    return false;
+  return ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
+}
+function inputKey(sessionId, requestId) {
+  return `${sessionId}:${requestId}`;
+}
+function getDivoomOutDir(homeDir = os2.homedir()) {
+  const xdg = process.env.XDG_DATA_HOME?.trim();
+  const baseDir = xdg && xdg.length > 0 && path3.isAbsolute(xdg) ? xdg : path3.join(homeDir, ".local", "share");
+  return path3.join(baseDir, "opencode", "storage", "oh-my-opencode-slim", "divoom", "captures");
+}
+
+class DivoomManager {
+  sender;
+  assetDir;
+  config;
+  parentStates = new Map;
+  pendingUserInputs = new Set;
+  orchestratorBusy = false;
+  latestRequestedGifPath;
+  lastGifPath;
+  sendQueue = Promise.resolve();
+  constructor(config, sender = defaultSender, options = {}) {
+    this.sender = sender;
+    this.config = {
+      ...DEFAULT_DIVOOM_CONFIG,
+      ...config,
+      enabled: isEnvEnabled(process.env[DIVOOM_ENABLE_ENV]) ? true : config?.enabled ?? false,
+      gifs: config?.gifs
+    };
+    this.assetDir = options.assetDir ?? resolveAssetDir();
+    if (options.sender) {
+      this.sender = options.sender;
+    }
+  }
+  onPluginLoad() {
+    this.show("intro");
+  }
+  onTaskStart(input) {
+    if (!input.parentSessionId || !input.callId)
+      return;
+    if (!isTaskArgs(input.args))
+      return;
+    const agent = normalizeAgentName(input.args.subagent_type);
+    if (!agent)
+      return;
+    const state = this.getParentState(input.parentSessionId);
+    const wasIdle = state.activeCalls.size === 0;
+    state.activeCalls.set(input.callId, agent);
+    this.orchestratorBusy = true;
+    if (wasIdle && !state.displayedAgent) {
+      state.displayedAgent = agent;
+    }
+    this.render();
+  }
+  onTaskEnd(input) {
+    if (!input.parentSessionId || !input.callId)
+      return;
+    const state = this.parentStates.get(input.parentSessionId);
+    if (!state)
+      return;
+    state.activeCalls.delete(input.callId);
+    if (state.activeCalls.size === 0) {
+      this.parentStates.delete(input.parentSessionId);
+    }
+    this.render();
+  }
+  onUserInputRequired(input) {
+    if (!input.sessionId || !input.requestId)
+      return;
+    this.pendingUserInputs.add(inputKey(input.sessionId, input.requestId));
+    this.render();
+  }
+  onUserInputResolved(input) {
+    if (!input.sessionId || !input.requestId)
+      return;
+    this.pendingUserInputs.delete(inputKey(input.sessionId, input.requestId));
+    this.render();
+  }
+  onOrchestratorStatus(input) {
+    if (!input.sessionId || !input.isOrchestrator)
+      return;
+    if (input.status === "busy") {
+      this.orchestratorBusy = true;
+      this.render();
+      return;
+    }
+    if (input.status === "idle") {
+      this.orchestratorBusy = false;
+      this.parentStates.delete(input.sessionId);
+      this.render();
+    }
+  }
+  onSessionDeleted(input) {
+    const sessionId = input.sessionId;
+    if (!sessionId)
+      return;
+    if (input.isOrchestrator)
+      this.orchestratorBusy = false;
+    this.parentStates.delete(sessionId);
+    this.pendingUserInputs = new Set(Array.from(this.pendingUserInputs).filter((key) => !key.startsWith(`${sessionId}:`)));
+    this.render();
+  }
+  render() {
+    if (this.pendingUserInputs.size > 0) {
+      this.show("input");
+      return;
+    }
+    const activeAgent = Array.from(this.parentStates.values()).find((state) => state.displayedAgent && state.activeCalls.size > 0)?.displayedAgent;
+    if (activeAgent) {
+      this.show(activeAgent);
+      return;
+    }
+    this.show(this.orchestratorBusy ? "orchestrator" : "intro");
+  }
+  getParentState(parentSessionId) {
+    const existing = this.parentStates.get(parentSessionId);
+    if (existing)
+      return existing;
+    const created = {
+      activeCalls: new Map
+    };
+    this.parentStates.set(parentSessionId, created);
+    return created;
+  }
+  show(agent) {
+    if (!this.config.enabled)
+      return;
+    if (!this.assetDir) {
+      log("[divoom] asset directory not found");
+      return;
+    }
+    const fileName = this.config.gifs?.[agent] ?? AGENT_GIFS[agent] ?? AGENT_GIFS.orchestrator;
+    const requestedGifPath = path3.isAbsolute(fileName) ? fileName : path3.join(this.assetDir, fileName);
+    const fallbackGifPath = path3.join(this.assetDir, AGENT_GIFS.intro);
+    const gifPath = existsSync2(requestedGifPath) ? requestedGifPath : agent === "input" ? fallbackGifPath : requestedGifPath;
+    if (!existsSync2(gifPath)) {
+      log("[divoom] gif not found", { agent, gifPath: requestedGifPath });
+      return;
+    }
+    if (gifPath === this.latestRequestedGifPath)
+      return;
+    this.latestRequestedGifPath = gifPath;
+    const outDir = getDivoomOutDir();
+    try {
+      mkdirSync2(outDir, { recursive: true });
+    } catch (error) {
+      this.clearLatestIfCurrent(gifPath);
+      log("[divoom] output directory not writable", {
+        outDir,
+        error: String(error)
+      });
+      return;
+    }
+    const call = {
+      command: this.config.python,
+      args: [
+        this.config.script,
+        gifPath,
+        "--size",
+        String(this.config.size),
+        "--fps",
+        String(this.config.fps),
+        "--speed",
+        String(this.config.speed),
+        "--max-frames",
+        String(this.config.maxFrames),
+        "--posterize-bits",
+        String(this.config.posterizeBits),
+        "--out-dir",
+        outDir
+      ]
+    };
+    this.sendQueue = this.sendQueue.catch(() => {}).then(async () => {
+      if (gifPath !== this.latestRequestedGifPath)
+        return;
+      if (!existsSync2(this.config.python)) {
+        this.clearLatestIfCurrent(gifPath);
+        log("[divoom] python executable not found", this.config.python);
+        return;
+      }
+      if (!existsSync2(this.config.script)) {
+        this.clearLatestIfCurrent(gifPath);
+        log("[divoom] sender script not found", this.config.script);
+        return;
+      }
+      try {
+        await this.sender(call);
+        this.lastGifPath = gifPath;
+        log("[divoom] showing gif", { agent, gifPath });
+      } catch (error) {
+        this.clearLatestIfCurrent(gifPath);
+        log("[divoom] failed to send gif", String(error));
+      }
+    });
+  }
+  async flush() {
+    await this.sendQueue.catch(() => {});
+  }
+  clearLatestIfCurrent(gifPath) {
+    if (this.latestRequestedGifPath === gifPath) {
+      this.latestRequestedGifPath = undefined;
+    }
+    if (this.lastGifPath === gifPath) {
+      this.lastGifPath = undefined;
+    }
+  }
+}
+function isTaskArgs(value) {
+  return typeof value === "object" && value !== null;
+}
+function defaultSender(call) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(call.command, call.args, {
+      detached: true,
+      stdio: "ignore"
+    });
+    child.once("error", reject);
+    child.once("spawn", () => {
+      child.unref();
+      resolve();
+    });
+  });
+}
+function createDivoomManager(config) {
+  return new DivoomManager(config);
+}
+
 // src/hooks/apply-patch/errors.ts
 var APPLY_PATCH_ERROR_PREFIX = {
   blocked: "apply_patch blocked",
@@ -20206,7 +20679,7 @@ function ensureApplyPatchError(error, context) {
 
 // src/hooks/apply-patch/execution-context.ts
 import * as fs3 from "node:fs/promises";
-import path3 from "node:path";
+import path4 from "node:path";
 
 // src/hooks/apply-patch/codec.ts
 function normalizeLineEndings(text) {
@@ -21075,7 +21548,7 @@ function isMissingPathError(error) {
 }
 async function real(target) {
   const parts = [];
-  let current = path3.resolve(target);
+  let current = path4.resolve(target);
   while (true) {
     const exact = await fs3.realpath(current).catch((error) => {
       if (isMissingPathError(error)) {
@@ -21084,19 +21557,19 @@ async function real(target) {
       throw createApplyPatchInternalError(`Failed to resolve real path: ${current}`, error);
     });
     if (exact) {
-      return parts.length === 0 ? exact : path3.join(exact, ...parts.reverse());
+      return parts.length === 0 ? exact : path4.join(exact, ...parts.reverse());
     }
-    const parent = path3.dirname(current);
+    const parent = path4.dirname(current);
     if (parent === current) {
-      return parts.length === 0 ? current : path3.join(current, ...parts.reverse());
+      return parts.length === 0 ? current : path4.join(current, ...parts.reverse());
     }
-    parts.push(path3.basename(current));
+    parts.push(path4.basename(current));
     current = parent;
   }
 }
 function inside(root, target) {
-  const rel = path3.relative(root, target);
-  return rel === "" || !rel.startsWith("..") && !path3.isAbsolute(rel);
+  const rel = path4.relative(root, target);
+  return rel === "" || !rel.startsWith("..") && !path4.isAbsolute(rel);
 }
 function createPathGuardContext(root, worktree) {
   return {
@@ -21106,7 +21579,7 @@ function createPathGuardContext(root, worktree) {
   };
 }
 async function realCached(ctx, target) {
-  const resolvedTarget = path3.resolve(target);
+  const resolvedTarget = path4.resolve(target);
   let pending = ctx.realCache.get(resolvedTarget);
   if (!pending) {
     pending = real(resolvedTarget);
@@ -21157,22 +21630,22 @@ async function assertRegularFile(ctx, filePath, verb) {
 function collectPatchTargets(root, hunks) {
   const targets = new Set;
   for (const hunk of hunks) {
-    targets.add(path3.resolve(root, hunk.path));
+    targets.add(path4.resolve(root, hunk.path));
     if (hunk.type === "update" && hunk.move_path) {
-      targets.add(path3.resolve(root, hunk.move_path));
+      targets.add(path4.resolve(root, hunk.move_path));
     }
   }
   return [...targets];
 }
 function toRelativePatchPath(root, target) {
-  const relative = path3.relative(root, target);
+  const relative = path4.relative(root, target);
   return (relative.length === 0 ? "." : relative).replaceAll("\\", "/");
 }
 function normalizePatchPath(root, value) {
-  return path3.isAbsolute(value) ? toRelativePatchPath(root, path3.resolve(value)) : value;
+  return path4.isAbsolute(value) ? toRelativePatchPath(root, path4.resolve(value)) : value;
 }
 function normalizePatchPaths(root, hunks) {
-  const resolvedRoot = path3.resolve(root);
+  const resolvedRoot = path4.resolve(root);
   const normalized = [];
   let changed = false;
   for (const hunk of hunks) {
@@ -21296,7 +21769,7 @@ function stageAddedText(contents) {
 `;
 }
 // src/hooks/apply-patch/rewrite.ts
-import path4 from "node:path";
+import path5 from "node:path";
 function normalizeTextLineEndings(text) {
   return text.replace(/\r\n/g, `
 `).replace(/\r/g, `
@@ -21453,7 +21926,7 @@ async function rewritePatch(root, patchText, cfg, worktree) {
     const dependencyGroups = new Map;
     for (const hunk of hunks) {
       if (hunk.type === "add") {
-        const filePath2 = path4.resolve(root, hunk.path);
+        const filePath2 = path5.resolve(root, hunk.path);
         await assertPreparedPathMissing(filePath2, "add");
         rewritten.push(hunk);
         clearDependencyGroup(filePath2);
@@ -21475,20 +21948,20 @@ async function rewritePatch(root, patchText, cfg, worktree) {
         continue;
       }
       if (hunk.type === "delete") {
-        const filePath2 = path4.resolve(root, hunk.path);
+        const filePath2 = path5.resolve(root, hunk.path);
         await getPreparedFileState(filePath2, "delete");
         clearDependencyGroup(filePath2);
         rewritten.push(hunk);
         staged.set(filePath2, { exists: false, derived: true });
         continue;
       }
-      const filePath = path4.resolve(root, hunk.path);
+      const filePath = path5.resolve(root, hunk.path);
       const currentDependency = dependencyGroups.get(filePath);
       const current = await getPreparedFileState(filePath, "update");
       if (!current.exists) {
         throw createApplyPatchVerificationError(`Failed to read file to update: ${filePath}`);
       }
-      const movePath = hunk.move_path ? path4.resolve(root, hunk.move_path) : undefined;
+      const movePath = hunk.move_path ? path5.resolve(root, hunk.move_path) : undefined;
       if (movePath && movePath !== filePath) {
         await assertPreparedPathMissing(movePath, "move");
       }
@@ -21584,6 +22057,15 @@ var APPLY_PATCH_RESCUE_OPTIONS = {
   prefixSuffix: true,
   lcsRescue: true
 };
+function replacePatchArgs(output, args, patchText) {
+  const nextArgs = { ...args, patchText };
+  try {
+    output.args = nextArgs;
+  } catch {
+    return false;
+  }
+  return output.args?.patchText === patchText;
+}
 function createApplyPatchHook(ctx) {
   function logHookStatus(state, data) {
     log(`apply-patch hook ${state}`, data);
@@ -21603,8 +22085,16 @@ function createApplyPatchHook(ctx) {
       try {
         const result = await rewritePatch(root, patchText, APPLY_PATCH_RESCUE_OPTIONS, worktree);
         if (result.changed) {
-          args.patchText = result.patchText;
-          logHookStatus("rewrite");
+          if (replacePatchArgs(output, args, result.patchText)) {
+            logHookStatus("rewrite");
+          } else {
+            logHookStatus("skipped", {
+              reason: "readonly output args",
+              failOpen: true,
+              rescueOptions: APPLY_PATCH_RESCUE_OPTIONS,
+              rewriteStage: "before-native"
+            });
+          }
           return;
         }
         logHookStatus("unchanged");
@@ -21636,78 +22126,28 @@ function createApplyPatchHook(ctx) {
     }
   };
 }
-// src/utils/compat.ts
-import { spawn as nodeSpawn } from "node:child_process";
-import { writeFile as fsWriteFile } from "node:fs/promises";
-var isBun = typeof globalThis.Bun !== "undefined";
-function collectStream(stream) {
-  if (!stream)
-    return () => Promise.resolve("");
-  const chunks = [];
-  stream.on("data", (chunk) => chunks.push(chunk));
-  return () => new Promise((resolve, reject) => {
-    if (!stream.readable) {
-      resolve(Buffer.concat(chunks).toString("utf-8"));
-      return;
-    }
-    stream.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
-    stream.on("error", reject);
-  });
-}
-function crossSpawn(command, options) {
-  const [cmd, ...args] = command;
-  const proc = nodeSpawn(cmd, args, {
-    stdio: [
-      options?.stdin ?? "ignore",
-      options?.stdout ?? "pipe",
-      options?.stderr ?? "pipe"
-    ],
-    cwd: options?.cwd,
-    env: options?.env
-  });
-  const stdoutCollector = collectStream(proc.stdout);
-  const stderrCollector = collectStream(proc.stderr);
-  const exited = new Promise((resolve, reject) => {
-    proc.on("error", reject);
-    proc.on("close", (code) => resolve(code ?? 1));
-  });
-  return {
-    proc,
-    stdout: stdoutCollector,
-    stderr: stderrCollector,
-    exited,
-    kill: (signal) => proc.kill(signal),
-    get exitCode() {
-      return proc.exitCode;
-    }
-  };
-}
-async function crossWrite(path5, data) {
-  await fsWriteFile(path5, Buffer.from(data));
-}
-
 // src/hooks/auto-update-checker/cache.ts
 import * as fs5 from "node:fs";
-import * as path7 from "node:path";
+import * as path8 from "node:path";
 // src/hooks/auto-update-checker/checker.ts
 import * as fs4 from "node:fs";
-import * as path6 from "node:path";
-import { fileURLToPath } from "node:url";
+import * as path7 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/hooks/auto-update-checker/constants.ts
-import * as os2 from "node:os";
-import * as path5 from "node:path";
+import * as os3 from "node:os";
+import * as path6 from "node:path";
 var PACKAGE_NAME = "oh-my-opencode-slim";
 var NPM_REGISTRY_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME}/dist-tags`;
 var NPM_FETCH_TIMEOUT = 5000;
 function getCacheDir() {
   if (process.platform === "win32") {
-    return path5.join(process.env.LOCALAPPDATA ?? os2.homedir(), "opencode");
+    return path6.join(process.env.LOCALAPPDATA ?? os3.homedir(), "opencode");
   }
-  return path5.join(os2.homedir(), ".cache", "opencode");
+  return path6.join(os3.homedir(), ".cache", "opencode");
 }
 var CACHE_DIR = getCacheDir();
-var INSTALLED_PACKAGE_JSON = path5.join(CACHE_DIR, "node_modules", PACKAGE_NAME, "package.json");
+var INSTALLED_PACKAGE_JSON = path6.join(CACHE_DIR, "node_modules", PACKAGE_NAME, "package.json");
 var configPaths = getOpenCodeConfigPaths();
 var USER_OPENCODE_CONFIG = configPaths[0];
 var USER_OPENCODE_CONFIG_JSONC = configPaths[1];
@@ -21742,8 +22182,8 @@ function extractChannel(version) {
 }
 function getConfigPaths(directory) {
   return [
-    path6.join(directory, ".opencode", "opencode.json"),
-    path6.join(directory, ".opencode", "opencode.jsonc"),
+    path7.join(directory, ".opencode", "opencode.json"),
+    path7.join(directory, ".opencode", "opencode.jsonc"),
     USER_OPENCODE_CONFIG,
     USER_OPENCODE_CONFIG_JSONC
   ];
@@ -21759,7 +22199,7 @@ function getLocalDevPath(directory) {
       for (const entry of plugins) {
         if (entry.startsWith("file://") && entry.includes(PACKAGE_NAME)) {
           try {
-            return fileURLToPath(entry);
+            return fileURLToPath2(entry);
           } catch {
             return entry.replace("file://", "");
           }
@@ -21772,9 +22212,9 @@ function getLocalDevPath(directory) {
 function findPackageJsonUp(startPath) {
   try {
     const stat2 = fs4.statSync(startPath);
-    let dir = stat2.isDirectory() ? startPath : path6.dirname(startPath);
+    let dir = stat2.isDirectory() ? startPath : path7.dirname(startPath);
     for (let i = 0;i < 10; i++) {
-      const pkgPath = path6.join(dir, "package.json");
+      const pkgPath = path7.join(dir, "package.json");
       if (fs4.existsSync(pkgPath)) {
         try {
           const content = fs4.readFileSync(pkgPath, "utf-8");
@@ -21783,7 +22223,7 @@ function findPackageJsonUp(startPath) {
             return pkgPath;
         } catch {}
       }
-      const parent = path6.dirname(dir);
+      const parent = path7.dirname(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -21808,7 +22248,7 @@ function getLocalDevVersion(directory) {
 }
 function getCurrentRuntimePackageJsonPath(currentModuleUrl = import.meta.url) {
   try {
-    const currentDir = path6.dirname(fileURLToPath(currentModuleUrl));
+    const currentDir = path7.dirname(fileURLToPath2(currentModuleUrl));
     return findPackageJsonUp(currentDir);
   } catch (err) {
     log("[auto-update-checker] Failed to resolve runtime package path:", err);
@@ -21892,7 +22332,7 @@ async function getLatestVersion(channel = "latest") {
 
 // src/hooks/auto-update-checker/cache.ts
 function removeFromBunLock(installDir, packageName) {
-  const lockPath = path7.join(installDir, "bun.lock");
+  const lockPath = path8.join(installDir, "bun.lock");
   if (!fs5.existsSync(lockPath))
     return false;
   try {
@@ -21943,7 +22383,7 @@ function ensureDependencyVersion(packageJsonPath, packageName, version) {
   }
 }
 function removeInstalledPackage(installDir, packageName) {
-  const pkgDir = path7.join(installDir, "node_modules", packageName);
+  const pkgDir = path8.join(installDir, "node_modules", packageName);
   if (!fs5.existsSync(pkgDir))
     return false;
   fs5.rmSync(pkgDir, { recursive: true, force: true });
@@ -21952,18 +22392,18 @@ function removeInstalledPackage(installDir, packageName) {
 }
 function resolveInstallContext(runtimePackageJsonPath = getCurrentRuntimePackageJsonPath()) {
   if (runtimePackageJsonPath) {
-    const packageDir = path7.dirname(runtimePackageJsonPath);
-    const nodeModulesDir = path7.dirname(packageDir);
-    if (path7.basename(packageDir) === PACKAGE_NAME && path7.basename(nodeModulesDir) === "node_modules") {
-      const installDir = path7.dirname(nodeModulesDir);
-      const packageJsonPath = path7.join(installDir, "package.json");
+    const packageDir = path8.dirname(runtimePackageJsonPath);
+    const nodeModulesDir = path8.dirname(packageDir);
+    if (path8.basename(packageDir) === PACKAGE_NAME && path8.basename(nodeModulesDir) === "node_modules") {
+      const installDir = path8.dirname(nodeModulesDir);
+      const packageJsonPath = path8.join(installDir, "package.json");
       if (fs5.existsSync(packageJsonPath)) {
         return { installDir, packageJsonPath };
       }
     }
     return null;
   }
-  const legacyPackageJsonPath = path7.join(CACHE_DIR, "package.json");
+  const legacyPackageJsonPath = path8.join(CACHE_DIR, "package.json");
   if (fs5.existsSync(legacyPackageJsonPath)) {
     return { installDir: CACHE_DIR, packageJsonPath: legacyPackageJsonPath };
   }
@@ -22097,7 +22537,7 @@ function showToast(ctx, title, message, variant = "info", duration = 3000) {
   }).catch(() => {});
 }
 // src/utils/agent-variant.ts
-function normalizeAgentName(agentName) {
+function normalizeAgentName2(agentName) {
   const trimmed = agentName.trim();
   return trimmed.startsWith("@") ? trimmed.slice(1) : trimmed;
 }
@@ -22109,7 +22549,7 @@ function getRuntimeAgentNames(config) {
   return [...unique];
 }
 function resolveRuntimeAgentName(config, agentName) {
-  const normalized = normalizeAgentName(agentName);
+  const normalized = normalizeAgentName2(agentName);
   if (!normalized) {
     return normalized;
   }
@@ -22121,7 +22561,7 @@ function resolveRuntimeAgentName(config, agentName) {
     if (!displayName) {
       continue;
     }
-    if (normalizeAgentName(displayName) === normalized) {
+    if (normalizeAgentName2(displayName) === normalized) {
       return internalName;
     }
   }
@@ -22137,7 +22577,7 @@ function createDisplayNameMentionRewriter(config) {
     if (!displayName) {
       continue;
     }
-    const normalizedDisplayName = normalizeAgentName(displayName);
+    const normalizedDisplayName = normalizeAgentName2(displayName);
     if (!normalizedDisplayName || normalizedDisplayName === internalName) {
       continue;
     }
@@ -22447,8 +22887,8 @@ function isPwshAvailable() {
   });
   return result.status === 0;
 }
-function escapePowerShellPath(path8) {
-  return path8.replace(/'/g, "''");
+function escapePowerShellPath(path9) {
+  return path9.replace(/'/g, "''");
 }
 function getWindowsZipExtractor() {
   const buildNumber = getWindowsBuildNumber();
@@ -22777,6 +23217,7 @@ function parseModel(model) {
   return { providerID: model.slice(0, slash), modelID: model.slice(slash + 1) };
 }
 var DEDUP_WINDOW_MS = 5000;
+var REPROMPT_DELAY_MS = 500;
 
 class ForegroundFallbackManager {
   client;
@@ -22909,11 +23350,20 @@ class ForegroundFallbackManager {
         log("[foreground-fallback] no user message found", { sessionID });
         return;
       }
-      try {
-        await this.client.session.abort({ path: { id: sessionID } });
-      } catch {}
-      await new Promise((r) => setTimeout(r, 500));
       const sessionClient = this.client.session;
+      if (typeof sessionClient.promptAsync !== "function") {
+        log("[foreground-fallback] promptAsync unavailable", { sessionID });
+        return;
+      }
+      try {
+        await abortSessionWithTimeout(this.client, sessionID);
+      } catch (error) {
+        log("[foreground-fallback] abort did not complete cleanly", {
+          sessionID,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+      await new Promise((r) => setTimeout(r, REPROMPT_DELAY_MS));
       await sessionClient.promptAsync({
         path: { id: sessionID },
         body: { parts: lastUser.parts, model: ref }
@@ -22960,8 +23410,8 @@ class ForegroundFallbackManager {
 // src/hooks/image-hook.ts
 import { createHash } from "node:crypto";
 import {
-  existsSync as existsSync4,
-  mkdirSync as mkdirSync2,
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync3,
   readdirSync as readdirSync2,
   rmdirSync,
   statSync as statSync3,
@@ -23056,7 +23506,7 @@ function writeUniqueFile(dir, name, data, log2) {
   const ext = extname(name);
   const base = basename2(name, ext) || name;
   let candidate = join7(dir, name);
-  if (existsSync4(candidate)) {
+  if (existsSync5(candidate)) {
     return candidate;
   }
   let counter = 0;
@@ -23094,14 +23544,14 @@ function processImageAttachments(args) {
   }
   const saveDir = join7(workDir, ".opencode", "images");
   if (messagesWithImages.length === 0) {
-    if (existsSync4(saveDir))
+    if (existsSync5(saveDir))
       cleanupAllSessions(saveDir);
     return;
   }
   const gitignorePath = join7(workDir, ".opencode", ".gitignore");
   try {
-    mkdirSync2(saveDir, { recursive: true });
-    if (!existsSync4(gitignorePath))
+    mkdirSync3(saveDir, { recursive: true });
+    if (!existsSync5(gitignorePath))
       writeFileSync3(gitignorePath, `*
 `);
   } catch (e) {
@@ -23112,7 +23562,7 @@ function processImageAttachments(args) {
     const sessionSubdir = msg.info.sessionID ? sanitizeFilename(msg.info.sessionID) : undefined;
     const targetDir = sessionSubdir ? join7(saveDir, sessionSubdir) : saveDir;
     try {
-      mkdirSync2(targetDir, { recursive: true });
+      mkdirSync3(targetDir, { recursive: true });
     } catch (e) {
       log2(`[image-hook] failed to create target image directory: ${e}`);
     }
@@ -23271,7 +23721,7 @@ function createPostFileToolNudgeHook(options = {}) {
   };
 }
 // src/hooks/task-session-manager/index.ts
-import path8 from "node:path";
+import path9 from "node:path";
 var AGENT_NAME_SET = new Set([
   "orchestrator",
   "oracle",
@@ -23296,8 +23746,8 @@ function extractPath(output) {
   return /<path>([^<]+)<\/path>/.exec(output)?.[1];
 }
 function normalizePath(root, file) {
-  const relative = path8.relative(root, file);
-  if (!relative || relative.startsWith("..") || path8.isAbsolute(relative)) {
+  const relative = path9.relative(root, file);
+  if (!relative || relative.startsWith("..") || path9.isAbsolute(relative)) {
     return file;
   }
   return relative;
@@ -23689,6 +24139,7 @@ function createTodoHygiene(options) {
 // src/hooks/todo-continuation/index.ts
 var HOOK_NAME = "todo-continuation";
 var COMMAND_NAME = "auto-continue";
+var TODO_STATE_TIMEOUT_MS = 500;
 var CONTINUATION_PROMPT = "[Auto-continue: enabled - there are incomplete todos remaining. Continue with the next uncompleted item. Press Esc to cancel. If you need user input or review for the next item, ask instead of proceeding.]";
 var TODO_HYGIENE_INSTRUCTION_OPEN = '<instruction name="todo_hygiene">';
 var TODO_HYGIENE_INSTRUCTION_CLOSE = "</instruction>";
@@ -23776,12 +24227,15 @@ function createTodoContinuationHook(ctx, config) {
     notifyingSessionIds: new Set,
     notificationBusyUntilBySession: new Map
   };
+  async function fetchTodos(sessionID) {
+    const result = await withTimeout(ctx.client.session.todo({
+      path: { id: sessionID }
+    }), TODO_STATE_TIMEOUT_MS, `Todo state lookup timed out after ${TODO_STATE_TIMEOUT_MS}ms`);
+    return result.data;
+  }
   const hygiene = createTodoHygiene({
     getTodoState: async (sessionID) => {
-      const result = await ctx.client.session.todo({
-        path: { id: sessionID }
-      });
-      const todos = result.data;
+      const todos = await fetchTodos(sessionID);
       const openTodos = todos.filter((todo) => !TERMINAL_TODO_STATUSES.includes(todo.status));
       return {
         hasOpenTodos: openTodos.length > 0,
@@ -23966,10 +24420,7 @@ function createTodoContinuationHook(ctx, config) {
       }
       if (autoEnable && !state.enabled) {
         try {
-          const todosResult = await ctx.client.session.todo({
-            path: { id: sessionID }
-          });
-          const todos = todosResult.data;
+          const todos = await fetchTodos(sessionID);
           const incompleteCount2 = todos.filter((t) => !TERMINAL_TODO_STATUSES.includes(t.status)).length;
           if (incompleteCount2 >= autoEnableThreshold) {
             state.enabled = true;
@@ -23995,10 +24446,7 @@ function createTodoContinuationHook(ctx, config) {
       let hasIncompleteTodos = false;
       let incompleteCount = 0;
       try {
-        const todosResult = await ctx.client.session.todo({
-          path: { id: sessionID }
-        });
-        const todos = todosResult.data;
+        const todos = await fetchTodos(sessionID);
         incompleteCount = todos.filter((t) => !TERMINAL_TODO_STATUSES.includes(t.status)).length;
         hasIncompleteTodos = incompleteCount > 0;
         log(`[${HOOK_NAME}] Fetched todos`, {
@@ -24209,10 +24657,7 @@ function createTodoContinuationHook(ctx, config) {
     });
     let hasIncompleteTodos = false;
     try {
-      const todosResult = await ctx.client.session.todo({
-        path: { id: input.sessionID }
-      });
-      const todos = todosResult.data;
+      const todos = await fetchTodos(input.sessionID);
       hasIncompleteTodos = todos.some((t) => !TERMINAL_TODO_STATUSES.includes(t.status));
     } catch (error) {
       log(`[${HOOK_NAME}] Warning: failed to fetch todos in command hook`, {
@@ -24236,7 +24681,7 @@ function createTodoContinuationHook(ctx, config) {
   };
 }
 // src/interview/manager.ts
-import path12 from "node:path";
+import path13 from "node:path";
 
 // src/interview/dashboard.ts
 import crypto from "node:crypto";
@@ -24245,28 +24690,28 @@ import fs7 from "node:fs/promises";
 import {
   createServer
 } from "node:http";
-import os3 from "node:os";
-import path10 from "node:path";
+import os4 from "node:os";
+import path11 from "node:path";
 import { URL as URL2 } from "node:url";
 
 // src/interview/document.ts
 import * as fsSync from "node:fs";
 import * as fs6 from "node:fs/promises";
-import * as path9 from "node:path";
+import * as path10 from "node:path";
 var DEFAULT_OUTPUT_FOLDER = "interview";
 function normalizeOutputFolder(outputFolder) {
   const normalized = outputFolder.trim().replace(/^\/+|\/+$/g, "");
   return normalized || DEFAULT_OUTPUT_FOLDER;
 }
 function createInterviewDirectoryPath(directory, outputFolder) {
-  return path9.join(directory, normalizeOutputFolder(outputFolder));
+  return path10.join(directory, normalizeOutputFolder(outputFolder));
 }
 function createInterviewFilePath(directory, outputFolder, idea) {
   const fileName = `${slugify(idea) || "interview"}.md`;
-  return path9.join(createInterviewDirectoryPath(directory, outputFolder), fileName);
+  return path10.join(createInterviewDirectoryPath(directory, outputFolder), fileName);
 }
 function relativeInterviewPath(directory, filePath) {
-  return path9.relative(directory, filePath) || path9.basename(filePath);
+  return path10.relative(directory, filePath) || path10.basename(filePath);
 }
 function resolveExistingInterviewPath(directory, outputFolder, value) {
   const trimmed = value.trim();
@@ -24275,22 +24720,22 @@ function resolveExistingInterviewPath(directory, outputFolder, value) {
   }
   const outputDir = createInterviewDirectoryPath(directory, outputFolder);
   const candidates = new Set;
-  const resolvedRoot = path9.resolve(directory);
-  if (path9.isAbsolute(trimmed)) {
+  const resolvedRoot = path10.resolve(directory);
+  if (path10.isAbsolute(trimmed)) {
     candidates.add(trimmed);
   } else {
-    candidates.add(path9.resolve(directory, trimmed));
-    candidates.add(path9.join(outputDir, trimmed));
+    candidates.add(path10.resolve(directory, trimmed));
+    candidates.add(path10.join(outputDir, trimmed));
     if (!trimmed.endsWith(".md")) {
-      candidates.add(path9.join(outputDir, `${trimmed}.md`));
+      candidates.add(path10.join(outputDir, `${trimmed}.md`));
     }
   }
   for (const candidate of candidates) {
-    if (path9.extname(candidate) !== ".md") {
+    if (path10.extname(candidate) !== ".md") {
       continue;
     }
-    const resolved = path9.resolve(candidate);
-    if (!resolved.startsWith(resolvedRoot + path9.sep) && resolved !== resolvedRoot) {
+    const resolved = path10.resolve(candidate);
+    if (!resolved.startsWith(resolvedRoot + path10.sep) && resolved !== resolvedRoot) {
       continue;
     }
     if (fsSync.existsSync(candidate)) {
@@ -24370,7 +24815,7 @@ function parseFrontmatter(content) {
   return result;
 }
 async function ensureInterviewFile(record) {
-  await fs6.mkdir(path9.dirname(record.markdownPath), { recursive: true });
+  await fs6.mkdir(path10.dirname(record.markdownPath), { recursive: true });
   try {
     await fs6.access(record.markdownPath);
   } catch {
@@ -26040,12 +26485,12 @@ function renderInterviewPage(interviewId, resumeSlug) {
 
 // src/interview/dashboard.ts
 function getAuthFilePath(port) {
-  const dataHome = process.env.XDG_DATA_HOME || path10.join(os3.homedir(), ".local", "share");
-  return path10.join(dataHome, "opencode", `.dashboard-${port}.json`);
+  const dataHome = process.env.XDG_DATA_HOME || path11.join(os4.homedir(), ".local", "share");
+  return path11.join(dataHome, "opencode", `.dashboard-${port}.json`);
 }
 function writeAuthFile(port, token) {
   const filePath = getAuthFilePath(port);
-  const dir = path10.dirname(filePath);
+  const dir = path11.dirname(filePath);
   try {
     fsSync2.mkdirSync(dir, { recursive: true });
   } catch {}
@@ -26142,7 +26587,7 @@ function createDashboardServer(config) {
   let scanDays = 30;
   function getKnownDirectories() {
     const dirs = new Set;
-    dirs.add(os3.homedir());
+    dirs.add(os4.homedir());
     for (const session2 of sessions.values()) {
       if (session2.directory)
         dirs.add(session2.directory);
@@ -26182,7 +26627,7 @@ function createDashboardServer(config) {
     const directories = getKnownDirectories();
     const items = [];
     for (const dir of directories) {
-      const interviewDir = path10.join(dir, config.outputFolder);
+      const interviewDir = path11.join(dir, config.outputFolder);
       let entries;
       try {
         entries = await fs7.readdir(interviewDir);
@@ -26194,7 +26639,7 @@ function createDashboardServer(config) {
           continue;
         let content;
         try {
-          content = await fs7.readFile(path10.join(interviewDir, entry), "utf8");
+          content = await fs7.readFile(path11.join(interviewDir, entry), "utf8");
         } catch {
           continue;
         }
@@ -26220,7 +26665,7 @@ function createDashboardServer(config) {
     const directories = getKnownDirectories();
     let rebuilt = 0;
     for (const dir of directories) {
-      const interviewDir = path10.join(dir, config.outputFolder);
+      const interviewDir = path11.join(dir, config.outputFolder);
       let entries;
       try {
         entries = await fs7.readdir(interviewDir);
@@ -26232,7 +26677,7 @@ function createDashboardServer(config) {
           continue;
         let content;
         try {
-          content = await fs7.readFile(path10.join(interviewDir, entry), "utf8");
+          content = await fs7.readFile(path11.join(interviewDir, entry), "utf8");
         } catch {
           continue;
         }
@@ -26258,7 +26703,7 @@ function createDashboardServer(config) {
           questions: [],
           pendingAnswers: null,
           lastUpdatedAt: fm.updatedAt ? new Date(fm.updatedAt).getTime() : Date.now(),
-          filePath: path10.join(interviewDir, entry),
+          filePath: path11.join(interviewDir, entry),
           nudgeAction: null
         });
         if (!sessions.has(fm.sessionID)) {
@@ -26522,7 +26967,7 @@ function createDashboardServer(config) {
         const dirs = getKnownDirectories();
         for (const dir of dirs) {
           const slug = extractResumeSlug(interviewId);
-          const candidate = path10.join(dir, config.outputFolder, `${slug}.md`);
+          const candidate = path11.join(dir, config.outputFolder, `${slug}.md`);
           try {
             document = await fs7.readFile(candidate, "utf8");
             markdownPath = candidate;
@@ -27048,9 +27493,9 @@ function createInterviewServer(deps) {
 }
 
 // src/interview/service.ts
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 import * as fs8 from "node:fs/promises";
-import * as path11 from "node:path";
+import * as path12 from "node:path";
 
 // src/interview/types.ts
 import { z as z3 } from "zod";
@@ -27252,7 +27697,7 @@ function openBrowser(url) {
     args = [url];
   }
   try {
-    const child = spawn(command, args, { detached: true, stdio: "ignore" });
+    const child = spawn2(command, args, { detached: true, stdio: "ignore" });
     child.on("error", (error) => {
       log("[interview] failed to open browser:", { error: error.message, url });
     });
@@ -27317,12 +27762,12 @@ function createInterviewService(ctx, config, deps) {
     if (!newSlug) {
       return;
     }
-    const currentFileName = path11.basename(interview.markdownPath, ".md");
+    const currentFileName = path12.basename(interview.markdownPath, ".md");
     if (currentFileName === newSlug) {
       return;
     }
-    const dir = path11.dirname(interview.markdownPath);
-    const newPath = path11.join(dir, `${newSlug}.md`);
+    const dir = path12.dirname(interview.markdownPath);
+    const newPath = path12.join(dir, `${newSlug}.md`);
     try {
       await fs8.access(newPath);
       return;
@@ -27398,9 +27843,9 @@ function createInterviewService(ctx, config, deps) {
     const messages = await loadMessages(sessionID);
     const title = extractTitle(document);
     const record = {
-      id: `${Date.now()}-${++idCounter}-${slugify(path11.basename(markdownPath, ".md")) || "interview"}`,
+      id: `${Date.now()}-${++idCounter}-${slugify(path12.basename(markdownPath, ".md")) || "interview"}`,
       sessionID,
-      idea: title || path11.basename(markdownPath, ".md"),
+      idea: title || path12.basename(markdownPath, ".md"),
       markdownPath,
       createdAt: nowIso(),
       status: "active",
@@ -27627,7 +28072,7 @@ function createInterviewService(ctx, config, deps) {
       return fileCache.items;
     }
     const outputDir = createInterviewDirectoryPath(ctx.directory, outputFolder);
-    const activePaths = new Set([...interviewsById.values()].filter((i) => i.status === "active").map((i) => path11.resolve(i.markdownPath)));
+    const activePaths = new Set([...interviewsById.values()].filter((i) => i.status === "active").map((i) => path12.resolve(i.markdownPath)));
     let entries;
     try {
       entries = await fs8.readdir(outputDir);
@@ -27638,8 +28083,8 @@ function createInterviewService(ctx, config, deps) {
     for (const entry of entries) {
       if (!entry.endsWith(".md"))
         continue;
-      const fullPath = path11.join(outputDir, entry);
-      if (activePaths.has(path11.resolve(fullPath)))
+      const fullPath = path12.join(outputDir, entry);
+      if (activePaths.has(path12.resolve(fullPath)))
         continue;
       let content;
       try {
@@ -27738,7 +28183,7 @@ function createInterviewManager(ctx, config) {
   const outputFolder = interviewConfig?.outputFolder ?? "interview";
   if (!dashboardEnabled) {
     const service2 = createInterviewService(ctx, interviewConfig);
-    const resolvedOutputPath = path12.join(ctx.directory, outputFolder);
+    const resolvedOutputPath = path13.join(ctx.directory, outputFolder);
     const server = createInterviewServer({
       getState: async (interviewId) => service2.getInterviewState(interviewId),
       listInterviewFiles: async () => service2.listInterviewFiles(),
@@ -27843,7 +28288,7 @@ function createInterviewManager(ctx, config) {
               listInterviews: () => service.listInterviews(),
               submitAnswers: async (interviewId, answers) => service.submitAnswers(interviewId, answers),
               handleNudgeAction: async (interviewId, action) => service.handleNudgeAction(interviewId, action),
-              outputFolder: path12.join(ctx.directory, outputFolder),
+              outputFolder: path13.join(ctx.directory, outputFolder),
               port: 0
             });
             service.setBaseUrlResolver(() => perSessionServer.ensureStarted());
@@ -28111,6 +28556,8 @@ function createBuiltinMcps(disabledMcps = [], websearchConfig) {
 }
 
 // src/multiplexer/tmux/index.ts
+var TMUX_LAYOUT_DEBOUNCE_MS = 150;
+
 class TmuxMultiplexer {
   type = "tmux";
   binaryPath = null;
@@ -28118,6 +28565,8 @@ class TmuxMultiplexer {
   storedLayout;
   storedMainPaneSize;
   targetPane = process.env.TMUX_PANE;
+  layoutTimer;
+  layoutGeneration = 0;
   constructor(layout = "main-vertical", mainPaneSize = 60) {
     this.storedLayout = layout;
     this.storedMainPaneSize = mainPaneSize;
@@ -28179,7 +28628,7 @@ class TmuxMultiplexer {
       if (exitCode === 0 && paneId) {
         const renameProc = crossSpawn([tmux, "select-pane", "-t", paneId, "-T", description.slice(0, 30)], { stdout: "ignore", stderr: "ignore" });
         await renameProc.exited;
-        await this.applyLayout(this.storedLayout, this.storedMainPaneSize);
+        this.scheduleLayout();
         log("[tmux] spawnPane: SUCCESS", { paneId });
         return { success: true, paneId };
       }
@@ -28216,7 +28665,7 @@ class TmuxMultiplexer {
       const stderr = await proc.stderr();
       log("[tmux] closePane: result", { exitCode, stderr: stderr.trim() });
       if (exitCode === 0) {
-        await this.applyLayout(this.storedLayout, this.storedMainPaneSize);
+        this.scheduleLayout();
         return true;
       }
       log("[tmux] closePane: failed (pane may already be closed)", { paneId });
@@ -28227,41 +28676,82 @@ class TmuxMultiplexer {
     }
   }
   async applyLayout(layout, mainPaneSize) {
+    if (this.layoutTimer) {
+      clearTimeout(this.layoutTimer);
+      this.layoutTimer = undefined;
+    }
+    this.layoutGeneration++;
+    await this.applyLayoutNow(layout, mainPaneSize);
+  }
+  scheduleLayout() {
+    if (this.layoutTimer)
+      clearTimeout(this.layoutTimer);
+    const gen = ++this.layoutGeneration;
+    this.layoutTimer = setTimeout(() => {
+      this.layoutTimer = undefined;
+      if (this.layoutGeneration === gen) {
+        this.applyLayoutNow(this.storedLayout, this.storedMainPaneSize);
+      }
+    }, TMUX_LAYOUT_DEBOUNCE_MS);
+    this.layoutTimer.unref?.();
+  }
+  async applyLayoutNow(layout, mainPaneSize) {
     const tmux = await this.getBinary();
     if (!tmux)
       return;
     this.storedLayout = layout;
     this.storedMainPaneSize = mainPaneSize;
     try {
-      const layoutProc = crossSpawn([tmux, "select-layout", ...this.targetArgs(), layout], {
-        stdout: "pipe",
-        stderr: "pipe"
-      });
-      await layoutProc.exited;
+      const layoutResult = await this.runTmux(tmux, [
+        "select-layout",
+        ...this.targetArgs(),
+        layout
+      ]);
+      if (layoutResult !== 0)
+        return;
       if (layout === "main-horizontal" || layout === "main-vertical") {
         const sizeOption = layout === "main-horizontal" ? "main-pane-height" : "main-pane-width";
-        const sizeProc = crossSpawn([
-          tmux,
+        const sizeResult = await this.runTmux(tmux, [
           "set-window-option",
           ...this.targetArgs(),
           sizeOption,
           `${mainPaneSize}%`
-        ], {
-          stdout: "pipe",
-          stderr: "pipe"
-        });
-        await sizeProc.exited;
-        const reapplyProc = crossSpawn([tmux, "select-layout", ...this.targetArgs(), layout], {
-          stdout: "pipe",
-          stderr: "pipe"
-        });
-        await reapplyProc.exited;
+        ]);
+        if (sizeResult !== 0)
+          return;
+        const reapplyResult = await this.runTmux(tmux, [
+          "select-layout",
+          ...this.targetArgs(),
+          layout
+        ]);
+        if (reapplyResult !== 0)
+          return;
       }
       log("[tmux] applyLayout: applied", { layout, mainPaneSize });
     } catch (err) {
       log("[tmux] applyLayout: exception", { error: String(err) });
     }
   }
+  async runTmux(tmux, args) {
+    const proc = crossSpawn([tmux, ...args], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const [exitCode, , stderr] = await Promise.all([
+      proc.exited,
+      proc.stdout(),
+      proc.stderr()
+    ]);
+    if (exitCode !== 0) {
+      log("[tmux] command failed", {
+        command: args[0],
+        args: [tmux, ...args],
+        exitCode,
+        stderr: stderr.trim()
+      });
+    }
+    return exitCode;
+  }
   async getBinary() {
     await this.isAvailable();
     return this.binaryPath;
@@ -28283,23 +28773,23 @@ class TmuxMultiplexer {
         return null;
       }
       const stdout = await proc.stdout();
-      const path13 = stdout.trim().split(`
+      const path14 = stdout.trim().split(`
 `)[0];
-      if (!path13) {
+      if (!path14) {
         log("[tmux] findBinary: no path in output");
         return null;
       }
-      const verifyProc = crossSpawn([path13, "-V"], {
+      const verifyProc = crossSpawn([path14, "-V"], {
         stdout: "pipe",
         stderr: "pipe"
       });
       const verifyExit = await verifyProc.exited;
       if (verifyExit !== 0) {
-        log("[tmux] findBinary: tmux -V failed", { path: path13, verifyExit });
+        log("[tmux] findBinary: tmux -V failed", { path: path14, verifyExit });
         return null;
       }
-      log("[tmux] findBinary: found", { path: path13 });
-      return path13;
+      log("[tmux] findBinary: found", { path: path14 });
+      return path14;
     } catch (err) {
       log("[tmux] findBinary: exception", { error: String(err) });
       return null;
@@ -29010,17 +29500,17 @@ async function isServerRunning(serverUrl, timeoutMs = 3000, maxAttempts = 2) {
 import { tool as tool2 } from "@opencode-ai/plugin/tool";
 
 // src/tools/ast-grep/cli.ts
-import { existsSync as existsSync8 } from "node:fs";
+import { existsSync as existsSync9 } from "node:fs";
 
 // src/tools/ast-grep/constants.ts
-import { existsSync as existsSync7, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync8, statSync as statSync4 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { dirname as dirname6, join as join11 } from "node:path";
 
 // src/tools/ast-grep/downloader.ts
-import { chmodSync, existsSync as existsSync6, mkdirSync as mkdirSync4, unlinkSync as unlinkSync4 } from "node:fs";
+import { chmodSync, existsSync as existsSync7, mkdirSync as mkdirSync5, unlinkSync as unlinkSync4 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { homedir as homedir4 } from "node:os";
+import { homedir as homedir5 } from "node:os";
 import { join as join10 } from "node:path";
 var REPO = "ast-grep/ast-grep";
 var DEFAULT_VERSION = "0.40.0";
@@ -29045,11 +29535,11 @@ var PLATFORM_MAP = {
 function getCacheDir2() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join10(homedir4(), "AppData", "Local");
+    const base2 = localAppData || join10(homedir5(), "AppData", "Local");
     return join10(base2, "oh-my-opencode-slim", "bin");
   }
   const xdgCache = process.env.XDG_CACHE_HOME;
-  const base = xdgCache || join10(homedir4(), ".cache");
+  const base = xdgCache || join10(homedir5(), ".cache");
   return join10(base, "oh-my-opencode-slim", "bin");
 }
 function getBinaryName() {
@@ -29057,7 +29547,7 @@ function getBinaryName() {
 }
 function getCachedBinaryPath() {
   const binaryPath = join10(getCacheDir2(), getBinaryName());
-  return existsSync6(binaryPath) ? binaryPath : null;
+  return existsSync7(binaryPath) ? binaryPath : null;
 }
 async function downloadAstGrep(version = DEFAULT_VERSION) {
   const platformKey = `${process.platform}-${process.arch}`;
@@ -29069,16 +29559,16 @@ async function downloadAstGrep(version = DEFAULT_VERSION) {
   const cacheDir = getCacheDir2();
   const binaryName = getBinaryName();
   const binaryPath = join10(cacheDir, binaryName);
-  if (existsSync6(binaryPath)) {
+  if (existsSync7(binaryPath)) {
     return binaryPath;
   }
-  const { arch, os: os4 } = platformInfo;
-  const assetName = `app-${arch}-${os4}.zip`;
+  const { arch, os: os5 } = platformInfo;
+  const assetName = `app-${arch}-${os5}.zip`;
   const downloadUrl = `https://github.com/${REPO}/releases/download/${version}/${assetName}`;
   console.log(`[oh-my-opencode-slim] Downloading ast-grep binary...`);
   try {
-    if (!existsSync6(cacheDir)) {
-      mkdirSync4(cacheDir, { recursive: true });
+    if (!existsSync7(cacheDir)) {
+      mkdirSync5(cacheDir, { recursive: true });
     }
     const response = await fetch(downloadUrl, { redirect: "follow" });
     if (!response.ok) {
@@ -29088,10 +29578,10 @@ async function downloadAstGrep(version = DEFAULT_VERSION) {
     const arrayBuffer = await response.arrayBuffer();
     await crossWrite(archivePath, arrayBuffer);
     await extractZip(archivePath, cacheDir);
-    if (existsSync6(archivePath)) {
+    if (existsSync7(archivePath)) {
       unlinkSync4(archivePath);
     }
-    if (process.platform !== "win32" && existsSync6(binaryPath)) {
+    if (process.platform !== "win32" && existsSync7(binaryPath)) {
       chmodSync(binaryPath, 493);
     }
     console.log(`[oh-my-opencode-slim] ast-grep binary ready.`);
@@ -29174,7 +29664,7 @@ function findSgCliPathSync() {
     const cliPkgPath = require2.resolve("@ast-grep/cli/package.json");
     const cliDir = dirname6(cliPkgPath);
     const sgPath = join11(cliDir, binaryName);
-    if (existsSync7(sgPath) && isValidBinary(sgPath)) {
+    if (existsSync8(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
   } catch {}
@@ -29186,16 +29676,16 @@ function findSgCliPathSync() {
       const pkgDir = dirname6(pkgPath);
       const astGrepName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
       const binaryPath = join11(pkgDir, astGrepName);
-      if (existsSync7(binaryPath) && isValidBinary(binaryPath)) {
+      if (existsSync8(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
     } catch {}
   }
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
-    for (const path13 of homebrewPaths) {
-      if (existsSync7(path13) && isValidBinary(path13)) {
-        return path13;
+    for (const path14 of homebrewPaths) {
+      if (existsSync8(path14) && isValidBinary(path14)) {
+        return path14;
       }
     }
   }
@@ -29212,8 +29702,8 @@ function getSgCliPath() {
   }
   return "sg";
 }
-function setSgCliPath(path13) {
-  resolvedCliPath = path13;
+function setSgCliPath(path14) {
+  resolvedCliPath = path14;
 }
 var DEFAULT_TIMEOUT_MS2 = 300000;
 var DEFAULT_MAX_OUTPUT_BYTES = 1 * 1024 * 1024;
@@ -29223,7 +29713,7 @@ var DEFAULT_MAX_MATCHES = 500;
 var initPromise = null;
 async function getAstGrepPath() {
   const currentPath = getSgCliPath();
-  if (currentPath !== "sg" && existsSync8(currentPath)) {
+  if (currentPath !== "sg" && existsSync9(currentPath)) {
     return currentPath;
   }
   if (initPromise) {
@@ -29231,7 +29721,7 @@ async function getAstGrepPath() {
   }
   initPromise = (async () => {
     const syncPath = findSgCliPathSync();
-    if (syncPath && existsSync8(syncPath)) {
+    if (syncPath && existsSync9(syncPath)) {
       setSgCliPath(syncPath);
       return syncPath;
     }
@@ -29270,7 +29760,7 @@ async function runSg(options) {
   const paths2 = options.paths && options.paths.length > 0 ? options.paths : ["."];
   args.push(...paths2);
   let cliPath = getSgCliPath();
-  if (!existsSync8(cliPath) && cliPath !== "sg") {
+  if (!existsSync9(cliPath) && cliPath !== "sg") {
     const downloadedPath = await getAstGrepPath();
     if (downloadedPath) {
       cliPath = downloadedPath;
@@ -29620,15 +30110,15 @@ Returns the councillor responses with a summary footer.`,
 }
 // src/tui-state.ts
 import * as fs9 from "node:fs";
-import * as os4 from "node:os";
-import * as path13 from "node:path";
+import * as os5 from "node:os";
+import * as path14 from "node:path";
 var STATE_DIR = "oh-my-opencode-slim";
 var STATE_FILE = "tui-state.json";
 function dataDir() {
-  return process.env.XDG_DATA_HOME ?? path13.join(os4.homedir(), ".local", "share");
+  return process.env.XDG_DATA_HOME ?? path14.join(os5.homedir(), ".local", "share");
 }
 function getTuiStatePath() {
-  return path13.join(dataDir(), "opencode", "storage", STATE_DIR, STATE_FILE);
+  return path14.join(dataDir(), "opencode", "storage", STATE_DIR, STATE_FILE);
 }
 function emptySnapshot() {
   return {
@@ -29664,7 +30154,7 @@ async function readTuiSnapshotAsync() {
 function writeTuiSnapshot(snapshot) {
   try {
     const filePath = getTuiStatePath();
-    fs9.mkdirSync(path13.dirname(filePath), { recursive: true });
+    fs9.mkdirSync(path14.dirname(filePath), { recursive: true });
     fs9.writeFileSync(filePath, `${JSON.stringify(snapshot)}
 `);
   } catch {}
@@ -29880,15 +30370,15 @@ var BINARY_PREFIXES = [
 ];
 var WEBFETCH_DESCRIPTION = "Fetch a URL with better extraction for static/docs pages. Supports llms.txt probing, content-focused HTML extraction, metadata, redirects, and an optional prompt processed by a cheap secondary model.";
 // src/tools/smartfetch/tool.ts
-import os5 from "node:os";
-import path17 from "node:path";
+import os6 from "node:os";
+import path18 from "node:path";
 import {
   tool as tool4
 } from "@opencode-ai/plugin";
 
 // src/tools/smartfetch/binary.ts
 import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
-import path14 from "node:path";
+import path15 from "node:path";
 function extensionForMime(contentType) {
   const mime = contentType.split(";")[0]?.trim().toLowerCase();
   const map = {
@@ -29909,10 +30399,10 @@ function buildBinaryResultMessage(fetchResult, savedPath) {
 async function saveBinary(binaryDir, data, contentType, filename) {
   await mkdir2(binaryDir, { recursive: true });
   const initialName = filename || `webfetch-${Date.now()}.${extensionForMime(contentType)}`;
-  const parsed = path14.parse(initialName);
+  const parsed = path15.parse(initialName);
   for (let attempt = 0;attempt < 1000; attempt++) {
     const candidateName = attempt === 0 ? initialName : `${parsed.name}-${attempt}${parsed.ext || `.${extensionForMime(contentType)}`}`;
-    const file = path14.join(binaryDir, candidateName);
+    const file = path15.join(binaryDir, candidateName);
     try {
       await writeFile2(file, data, { flag: "wx" });
       return file;
@@ -30566,7 +31056,7 @@ var L = class u2 {
 };
 
 // src/tools/smartfetch/network.ts
-import path15 from "node:path";
+import path16 from "node:path";
 
 // src/tools/smartfetch/utils.ts
 var import_readability = __toESM(require_readability(), 1);
@@ -31291,7 +31781,7 @@ function inferFilenameFromUrl(url) {
 function truncateFilename(name, maxLength = 180) {
   if (name.length <= maxLength)
     return name;
-  const parsed = path15.parse(name);
+  const parsed = path16.parse(name);
   const ext = parsed.ext || "";
   const baseLimit = Math.max(1, maxLength - ext.length);
   return `${parsed.name.slice(0, baseLimit)}${ext}`;
@@ -31461,9 +31951,9 @@ function isInvalidLlmsResult(fetchResult) {
 }
 
 // src/tools/smartfetch/secondary-model.ts
-import { existsSync as existsSync9 } from "node:fs";
+import { existsSync as existsSync10 } from "node:fs";
 import { readFile as readFile4 } from "node:fs/promises";
-import path16 from "node:path";
+import path17 from "node:path";
 function parseModelRef(value) {
   if (!value)
     return;
@@ -31489,8 +31979,8 @@ function pickAgentModelRef(value) {
 }
 function findPreferredOpenCodeConfigPath(baseDir) {
   for (const file of ["opencode.jsonc", "opencode.json"]) {
-    const fullPath = path16.join(baseDir, file);
-    if (existsSync9(fullPath))
+    const fullPath = path17.join(baseDir, file);
+    if (existsSync10(fullPath))
       return fullPath;
   }
   return;
@@ -31506,7 +31996,7 @@ async function readOpenCodeConfigFile(configPath) {
   }
 }
 async function readEffectiveOpenCodeConfig(directory) {
-  const projectDir = path16.join(directory, ".opencode");
+  const projectDir = path17.join(directory, ".opencode");
   const userDirs = getConfigSearchDirs();
   const projectPath = findPreferredOpenCodeConfigPath(projectDir);
   const userPath = userDirs.map((configDir) => findPreferredOpenCodeConfigPath(configDir)).find(Boolean);
@@ -31667,7 +32157,7 @@ async function runSecondaryModelWithFallback(client, directory, models, prompt,
 // src/tools/smartfetch/tool.ts
 var z5 = tool4.schema;
 function createWebfetchTool(pluginCtx, options = {}) {
-  const binaryDir = options.binaryDir || path17.join(os5.tmpdir(), "opencode-smartfetch");
+  const binaryDir = options.binaryDir || path18.join(os6.tmpdir(), "opencode-smartfetch");
   return tool4({
     description: WEBFETCH_DESCRIPTION,
     args: {
@@ -32148,6 +32638,460 @@ function createWebfetchTool(pluginCtx, options = {}) {
     }
   });
 }
+// src/tools/subtask/command.ts
+var COMMAND_NAME4 = "subtask";
+var SUBTASK_COMMAND_TEMPLATE = `Start a focused subtask worker.
+
+The user's request below is the full scope for the worker. Do not broaden it.
+Create a self-contained worker prompt that includes:
+- the exact objective
+- relevant context from this conversation
+- specific files/paths that matter
+- expected deliverables
+- validation the worker should run, if applicable
+
+USER REQUEST:
+$ARGUMENTS
+
+Then call the subtask tool:
+\`subtask(prompt="...", files=["src/foo.ts", "docs/bar.md"])\`
+
+Only include files that are clearly relevant. If no files are needed, omit files.`;
+function createSubtaskCommandManager(_ctx, state) {
+  function registerCommand(opencodeConfig) {
+    const configCommand = opencodeConfig.command;
+    if (!configCommand?.[COMMAND_NAME4]) {
+      if (!opencodeConfig.command) {
+        opencodeConfig.command = {};
+      }
+      opencodeConfig.command[COMMAND_NAME4] = {
+        description: "Create a focused subtask prompt for a new session",
+        template: SUBTASK_COMMAND_TEMPLATE
+      };
+    }
+  }
+  return {
+    registerCommand,
+    handleEvent(input) {
+      if (input.event.type === "session.created") {
+        const info = input.event.properties?.info;
+        if (!info?.id || !info.parentID)
+          return;
+        const source = state.sourceFor(info.parentID);
+        if (source)
+          state.markSession(info.id, source);
+        return;
+      }
+      if (input.event.type !== "session.deleted")
+        return;
+      const sessionID = input.event.properties?.info?.id ?? input.event.properties?.sessionID;
+      if (sessionID)
+        state.unmarkSession(sessionID);
+    }
+  };
+}
+// src/tools/subtask/files.ts
+import * as fs11 from "node:fs/promises";
+import * as path20 from "node:path";
+
+// src/tools/subtask/vendor.ts
+import * as fs10 from "node:fs/promises";
+import * as path19 from "node:path";
+var DEFAULT_READ_LIMIT = 2000;
+var MAX_LINE_LENGTH = 2000;
+var MAX_BYTES = 50 * 1024;
+var MAX_LINE_SUFFIX = `... (line truncated to ${MAX_LINE_LENGTH} chars)`;
+var MAX_BYTES_LABEL = `${MAX_BYTES / 1024} KB`;
+var SAMPLE_BYTES = 4096;
+var BINARY_EXTENSIONS = new Set([
+  ".zip",
+  ".tar",
+  ".gz",
+  ".exe",
+  ".dll",
+  ".so",
+  ".class",
+  ".jar",
+  ".war",
+  ".7z",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".ppt",
+  ".pptx",
+  ".odt",
+  ".ods",
+  ".odp",
+  ".bin",
+  ".dat",
+  ".obj",
+  ".o",
+  ".a",
+  ".lib",
+  ".wasm",
+  ".pyc",
+  ".pyo"
+]);
+async function isBinaryFile(filepath) {
+  const ext = path19.extname(filepath).toLowerCase();
+  if (BINARY_EXTENSIONS.has(ext)) {
+    return true;
+  }
+  try {
+    const file = await fs10.open(filepath, "r");
+    try {
+      const buffer = Buffer.alloc(SAMPLE_BYTES);
+      const result = await file.read(buffer, 0, SAMPLE_BYTES, 0);
+      if (result.bytesRead === 0)
+        return false;
+      const bytes = buffer.subarray(0, result.bytesRead);
+      let nonPrintableCount = 0;
+      for (let i = 0;i < bytes.length; i++) {
+        const byte = bytes[i];
+        if (byte === undefined)
+          continue;
+        if (byte === 0)
+          return true;
+        if (byte < 9 || byte > 13 && byte < 32) {
+          nonPrintableCount++;
+        }
+      }
+      return nonPrintableCount / bytes.length > 0.3;
+    } finally {
+      await file.close();
+    }
+  } catch {
+    return false;
+  }
+}
+function formatFileContent(_filepath, content) {
+  const cappedContent = Buffer.byteLength(content, "utf8") > MAX_BYTES;
+  const contentToFormat = cappedContent ? content.slice(0, MAX_BYTES) : content;
+  const lines = contentToFormat.split(`
+`);
+  const limit = DEFAULT_READ_LIMIT;
+  const offset = 0;
+  const raw = lines.slice(offset, offset + limit).map((line) => {
+    return line.length > MAX_LINE_LENGTH ? `${line.substring(0, MAX_LINE_LENGTH)}${MAX_LINE_SUFFIX}` : line;
+  });
+  const formatted = raw.map((line, index) => {
+    return `${index + offset + 1}: ${line}`;
+  });
+  let output = [
+    `<path>${_filepath}</path>`,
+    "<type>file</type>",
+    `<content>
+`
+  ].join(`
+`);
+  output += formatted.join(`
+`);
+  const totalLines = lines.length;
+  const lastReadLine = offset + formatted.length;
+  const hasMoreLines = totalLines > lastReadLine;
+  if (cappedContent) {
+    output += `
+
+(Output capped at ${MAX_BYTES_LABEL}. Showing lines 1-${lastReadLine}. Use offset=${lastReadLine + 1} to continue.)`;
+  } else if (hasMoreLines) {
+    output += `
+
+(Showing lines 1-${lastReadLine} of ${totalLines}. Use offset=${lastReadLine + 1} to continue.)`;
+  } else {
+    output += `
+
+(End of file - total ${totalLines} lines)`;
+  }
+  output += `
+</content>`;
+  return output;
+}
+
+// src/tools/subtask/files.ts
+var FILE_REGEX = /(?<![\w`])@(\.?[^\s`,.]*(?:\.[^\s`,.]+)*)/g;
+var TRAILING_PATH_PUNCTUATION = /[!?:;]+$/;
+function cleanFileReference(ref) {
+  return ref.replace(/^@/, "").replace(TRAILING_PATH_PUNCTUATION, "");
+}
+function parseFileReferences(text) {
+  const fileRefs = new Set;
+  for (const match of text.matchAll(FILE_REGEX)) {
+    if (match[1]) {
+      fileRefs.add(cleanFileReference(match[1]));
+    }
+  }
+  return fileRefs;
+}
+async function buildSyntheticFileParts(directory, refs) {
+  const parts = [];
+  const realDirectory = await fs11.realpath(directory);
+  for (const ref of refs) {
+    const filepath = path20.resolve(directory, ref);
+    const relative3 = path20.relative(directory, filepath);
+    if (relative3.startsWith("..") || path20.isAbsolute(relative3))
+      continue;
+    try {
+      const realFilepath = await fs11.realpath(filepath);
+      const realRelative = path20.relative(realDirectory, realFilepath);
+      if (realRelative.startsWith("..") || path20.isAbsolute(realRelative)) {
+        continue;
+      }
+      const stats = await fs11.stat(realFilepath);
+      if (!stats.isFile())
+        continue;
+      if (await isBinaryFile(realFilepath))
+        continue;
+      const content = await fs11.readFile(realFilepath, "utf-8");
+      parts.push({
+        type: "text",
+        synthetic: true,
+        text: `Called the Read tool with the following input: ${JSON.stringify({ filePath: realFilepath })}`
+      });
+      parts.push({
+        type: "text",
+        synthetic: true,
+        text: formatFileContent(realFilepath, content)
+      });
+    } catch {}
+  }
+  return parts;
+}
+// src/tools/subtask/state.ts
+function createSubtaskState() {
+  const sourceBySession = new Map;
+  return {
+    markSession(sessionID, sourceSessionID) {
+      sourceBySession.set(sessionID, sourceSessionID);
+    },
+    unmarkSession(sessionID) {
+      sourceBySession.delete(sessionID);
+    },
+    isSubtaskSession(sessionID) {
+      return sourceBySession.has(sessionID);
+    },
+    sourceFor(sessionID) {
+      return sourceBySession.get(sessionID);
+    }
+  };
+}
+// src/tools/subtask/tools.ts
+import { tool as tool5 } from "@opencode-ai/plugin";
+var SUBTASK_TIMEOUT_MS = 5 * 60 * 1000;
+var SUBTASK_SUMMARY_TAG_REGEX = /<\/?subtask_summary>/g;
+function normalizeSubtaskSummary(text) {
+  return text.replace(SUBTASK_SUMMARY_TAG_REGEX, "").trim();
+}
+function getAbortSignal(context) {
+  if (!context || typeof context !== "object" || !("abort" in context)) {
+    return;
+  }
+  const signal = context.abort;
+  return signal && typeof signal === "object" && "addEventListener" in signal && "removeEventListener" in signal && "aborted" in signal ? signal : undefined;
+}
+function createSubtaskTool(ctx, state, depthTracker) {
+  const client = ctx.client;
+  return tool5({
+    description: "Run a child worker session and return its completion summary to the caller",
+    args: {
+      prompt: tool5.schema.string().describe("The generated subtask prompt"),
+      files: tool5.schema.array(tool5.schema.string()).optional().describe("Array of file paths to load into the new session's context")
+    },
+    async execute(args, context) {
+      const directory = context && typeof context === "object" && "directory" in context && typeof context.directory === "string" ? context.directory : ctx.directory;
+      const sessionID = context && typeof context === "object" && "sessionID" in context ? context.sessionID : "unknown";
+      const abortSignal = getAbortSignal(context);
+      if (state.isSubtaskSession(sessionID)) {
+        return "Nested subtask is disabled: this session is already a subtask worker. Finish this worker and return its summary to the parent session instead.";
+      }
+      if (sessionID !== "unknown" && depthTracker && depthTracker.getDepth(sessionID) + 1 > depthTracker.maxDepth) {
+        return `Subtask worker blocked: max subagent depth ${depthTracker.maxDepth} would be exceeded.`;
+      }
+      const sessionReference = `You are a subtask worker spawned by parent session ${sessionID}.
+
+Your job is bounded: complete only the task below. Do not expand scope.
+If needed context is missing, use read_session to inspect the parent session.
+Do not spawn another subtask.`;
+      const files = new Set([
+        ...parseFileReferences(args.prompt),
+        ...(args.files ?? []).map(cleanFileReference)
+      ]);
+      const fileRefs = files.size > 0 ? [...files].map((f) => `@${f}`).join(" ") : "";
+      const fullPrompt = fileRefs ? `${sessionReference}
+
+TASK:
+${args.prompt}
+
+FILES PROVIDED:
+${fileRefs}` : `${sessionReference}
+
+TASK:
+${args.prompt}`;
+      let childSessionID;
+      try {
+        const session2 = await client.session.create({
+          responseStyle: "data",
+          throwOnError: true,
+          query: { directory },
+          body: {
+            parentID: sessionID === "unknown" ? undefined : sessionID,
+            title: `Subtask worker from ${sessionID}`
+          }
+        });
+        childSessionID = session2?.data?.id ?? session2?.id;
+        if (!childSessionID) {
+          throw new Error("Subtask worker session did not return an id");
+        }
+        if (sessionID !== "unknown" && depthTracker) {
+          const registered = depthTracker.registerChild(sessionID, childSessionID);
+          if (!registered) {
+            throw new Error("Subtask worker blocked: max subagent depth exceeded");
+          }
+        }
+        state.markSession(childSessionID, sessionID);
+        await promptWithTimeout(client, {
+          responseStyle: "data",
+          throwOnError: true,
+          query: { directory },
+          path: { id: childSessionID },
+          body: {
+            agent: "orchestrator",
+            parts: [
+              {
+                type: "text",
+                text: `${fullPrompt}
+
+Instructions:
+1. Understand the task and relevant file context.
+2. Make only necessary changes.
+3. Run the most relevant validation checks when practical.
+4. Stop when the requested task is done.
+
+Return your final response in this format:
+
+<subtask_summary>
+Status: completed | blocked | partial
+
+What changed:
+- ...
+
+Files touched:
+- ...
+
+Validation:
+- ...
+
+Risks / follow-up:
+- ...
+</subtask_summary>`
+              },
+              ...await buildSyntheticFileParts(directory, files)
+            ]
+          }
+        }, SUBTASK_TIMEOUT_MS, abortSignal);
+        const extraction = await extractSessionResult(client, childSessionID, {
+          directory,
+          includeReasoning: false
+        });
+        if (extraction.empty) {
+          throw new Error("Subtask worker returned no summary");
+        }
+        const summary = normalizeSubtaskSummary(extraction.text);
+        return [
+          `task_id: ${childSessionID}`,
+          "",
+          "<subtask_summary>",
+          summary,
+          "</subtask_summary>"
+        ].join(`
+`);
+      } finally {
+        if (childSessionID) {
+          try {
+            await client.session.abort({
+              path: { id: childSessionID },
+              query: { directory }
+            });
+            state.unmarkSession(childSessionID);
+          } catch {}
+        }
+      }
+    }
+  });
+}
+function formatTranscript(messages, limit) {
+  const lines = [];
+  for (const msg of messages) {
+    const role = msg.info?.role;
+    const parts = msg.parts;
+    if (role === "user") {
+      lines.push("## User");
+      for (const part of parts) {
+        if (part.type === "text" && !part.ignored && typeof part.text === "string") {
+          lines.push(part.text);
+        }
+        if (part.type === "file") {
+          lines.push(`[Attached: ${part.filename || "file"}]`);
+        }
+      }
+      lines.push("");
+    }
+    if (role === "assistant") {
+      lines.push("## Assistant");
+      for (const part of parts) {
+        if (part.type === "text" && typeof part.text === "string") {
+          lines.push(part.text);
+        }
+        if (part.type === "tool" && part.state?.status === "completed" && part.tool) {
+          lines.push(`[Tool: ${part.tool}] ${part.state.title ?? ""}`);
+        }
+      }
+      lines.push("");
+    }
+  }
+  const output = lines.join(`
+`).trim();
+  if (messages.length >= (limit ?? 100)) {
+    return output + `
+
+(Showing ${messages.length} most recent messages. Use a higher 'limit' to see more.)`;
+  }
+  return `${output}
+
+(End of session - ${messages.length} messages)`;
+}
+function createReadSessionTool(client, state) {
+  return tool5({
+    description: "Read the conversation transcript from a previous session. Use this when you need specific information from the source session that wasn't included in the subtask summary.",
+    args: {
+      sessionID: tool5.schema.string().describe("The full session ID (e.g., sess_01jxyz...)"),
+      limit: tool5.schema.number().optional().describe("Maximum number of messages to read (defaults to 100, max 500)")
+    },
+    async execute(args, context) {
+      const limit = Math.min(args.limit ?? 100, 500);
+      const directory = context && typeof context === "object" && "directory" in context && typeof context.directory === "string" ? context.directory : undefined;
+      const callerSessionID = context && typeof context === "object" && "sessionID" in context ? context.sessionID : undefined;
+      if (!callerSessionID || !state.isSubtaskSession(callerSessionID)) {
+        return "read_session is only available from subtask worker sessions.";
+      }
+      if (state.sourceFor(callerSessionID) !== args.sessionID) {
+        return "read_session can only read the source session for this subtask worker.";
+      }
+      try {
+        const response = await client.session.messages({
+          path: { id: args.sessionID },
+          query: { limit, ...directory ? { directory } : {} }
+        });
+        if (!response.data || response.data.length === 0) {
+          return "Session has no messages or does not exist.";
+        }
+        return formatTranscript(response.data, limit);
+      } catch (error) {
+        return `Could not read session ${args.sessionID}: ${error instanceof Error ? error.message : "Unknown error"}`;
+      }
+    }
+  });
+}
 // src/utils/subagent-depth.ts
 class SubagentDepthTracker {
   depthBySession = new Map;
@@ -32263,9 +33207,12 @@ var OhMyOpenCodeLite = async (ctx) => {
   let taskSessionManagerHook;
   let interviewManager;
   let presetManager;
+  let divoomManager;
   let councilTools;
   let webfetch;
   let rewriteDisplayNameMentions;
+  let subtaskCommandManager;
+  let subtaskState;
   let toolCount = 0;
   try {
     config = loadPluginConfig(ctx.directory);
@@ -32357,7 +33304,10 @@ var OhMyOpenCodeLite = async (ctx) => {
     });
     interviewManager = createInterviewManager(ctx, config);
     presetManager = createPresetManager(ctx, config);
-    toolCount = Object.keys(councilTools).length + Object.keys(todoContinuationHook.tool).length + 1 + 2;
+    divoomManager = createDivoomManager(config.divoom);
+    subtaskState = createSubtaskState();
+    subtaskCommandManager = createSubtaskCommandManager(ctx, subtaskState);
+    toolCount = Object.keys(councilTools).length + Object.keys(todoContinuationHook.tool).length + 1 + 2 + 2;
   } catch (err) {
     log("[plugin] FATAL: init failed", String(err));
     await appLog(ctx, "error", `INIT FAILED: ${String(err)}. Report at github.com/alvinunreal/oh-my-opencode-slim/issues/310`);
@@ -32393,6 +33343,7 @@ var OhMyOpenCodeLite = async (ctx) => {
       appLog(ctx, "warn", msg).catch(() => {});
     }
   });
+  divoomManager.onPluginLoad();
   return {
     name: "oh-my-opencode-slim",
     agent: agents,
@@ -32401,7 +33352,9 @@ var OhMyOpenCodeLite = async (ctx) => {
       webfetch,
       ...todoContinuationHook.tool,
       ast_grep_search,
-      ast_grep_replace
+      ast_grep_replace,
+      subtask: createSubtaskTool(ctx, subtaskState, depthTracker),
+      read_session: createReadSessionTool(ctx.client, subtaskState)
     },
     mcp: mcps,
     config: async (opencodeConfig) => {
@@ -32598,6 +33551,7 @@ var OhMyOpenCodeLite = async (ctx) => {
       }
       interviewManager.registerCommand(opencodeConfig);
       presetManager.registerCommand(opencodeConfig);
+      subtaskCommandManager.registerCommand(opencodeConfig);
     },
     event: async (input) => {
       const event = input.event;
@@ -32625,6 +33579,38 @@ var OhMyOpenCodeLite = async (ctx) => {
       await multiplexerSessionManager.onSessionDeleted(event);
       await interviewManager.handleEvent(input);
       await taskSessionManagerHook.event(input);
+      subtaskCommandManager.handleEvent(input);
+      if (event.type === "permission.asked" || event.type === "question.asked") {
+        const props = event.properties;
+        divoomManager.onUserInputRequired({
+          sessionId: props?.sessionID,
+          requestId: props?.id ?? props?.requestID
+        });
+      }
+      if (event.type === "permission.replied" || event.type === "question.replied" || event.type === "question.rejected") {
+        const props = event.properties;
+        divoomManager.onUserInputResolved({
+          sessionId: props?.sessionID,
+          requestId: props?.requestID ?? props?.id
+        });
+      }
+      if (input.event.type === "session.status") {
+        const props = input.event.properties;
+        const sessionID = props?.sessionID;
+        divoomManager.onOrchestratorStatus({
+          sessionId: sessionID,
+          status: props?.status?.type,
+          isOrchestrator: sessionID ? sessionAgentMap.get(sessionID) === "orchestrator" : false
+        });
+      }
+      if (input.event.type === "session.deleted") {
+        const props = input.event.properties;
+        const sessionID = props?.info?.id ?? props?.sessionID;
+        divoomManager.onSessionDeleted({
+          sessionId: sessionID,
+          isOrchestrator: sessionID ? sessionAgentMap.get(sessionID) === "orchestrator" : false
+        });
+      }
       if (input.event.type === "session.deleted") {
         const props = input.event.properties;
         const sessionID = props?.info?.id ?? props?.sessionID;
@@ -32639,6 +33625,13 @@ var OhMyOpenCodeLite = async (ctx) => {
     "tool.execute.before": async (input, output) => {
       await applyPatchHook["tool.execute.before"](input, output);
       await taskSessionManagerHook["tool.execute.before"](input, output);
+      if (input.tool.toLowerCase() === "task") {
+        divoomManager.onTaskStart({
+          parentSessionId: input.sessionID,
+          callId: input.callID,
+          args: output.args
+        });
+      }
     },
     "command.execute.before": async (input, output) => {
       await todoContinuationHook.handleCommandExecuteBefore(input, output);
@@ -32701,11 +33694,31 @@ ${output.system[0]}` : "");
       await filterAvailableSkillsHook["experimental.chat.messages.transform"](input, typedOutput);
     },
     "tool.execute.after": async (input, output) => {
-      await delegateTaskRetryHook["tool.execute.after"](input, output);
-      await jsonErrorRecoveryHook["tool.execute.after"](input, output);
-      await todoContinuationHook.handleToolExecuteAfter(input, output);
-      await postFileToolNudgeHook["tool.execute.after"](input, output);
-      await taskSessionManagerHook["tool.execute.after"](input, output);
+      const meta = input;
+      const runPostToolHook = async (name, fn) => {
+        try {
+          await fn();
+        } catch (error) {
+          log("[plugin] post-tool hook failed open", {
+            hook: name,
+            tool: meta.tool,
+            sessionID: meta.sessionID,
+            callID: meta.callID,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      };
+      await runPostToolHook("delegate-task-retry", () => delegateTaskRetryHook["tool.execute.after"](input, output));
+      await runPostToolHook("json-error-recovery", () => jsonErrorRecoveryHook["tool.execute.after"](input, output));
+      await runPostToolHook("todo-continuation", () => todoContinuationHook.handleToolExecuteAfter(input, output));
+      await runPostToolHook("post-file-tool-nudge", () => postFileToolNudgeHook["tool.execute.after"](input, output));
+      await runPostToolHook("task-session-manager", () => taskSessionManagerHook["tool.execute.after"](input, output));
+      if (input.tool.toLowerCase() === "task") {
+        divoomManager.onTaskEnd({
+          parentSessionId: input.sessionID,
+          callId: input.callID
+        });
+      }
     }
   };
 };