oh-my-opencode-slim 1.0.6 → 1.0.7

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;
@@ -18530,6 +18530,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 +18592,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 +18609,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 +18676,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 +18713,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 +18732,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 +18801,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;
 }
@@ -18771,11 +18856,17 @@ 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);
       })
     ]);
+  } catch (error) {
+    if (error instanceof OperationTimeoutError) {
+      try {
+        await abortSessionWithTimeout(client, sessionId);
+      } catch {}
+    }
+    throw error;
   } finally {
     clearTimeout(timer);
   }
@@ -18822,7 +18913,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
@@ -19207,7 +19298,8 @@ function createCouncillorAgent(model, customPrompt, customAppendPrompt) {
         grep: "allow",
         lsp: "allow",
         list: "allow",
-        codesearch: "allow"
+        codesearch: "allow",
+        ast_grep_search: "allow"
       }
     }
   };
@@ -19529,10 +19621,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 +19662,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 +19722,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 +19811,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 +20240,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 +20588,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 +21457,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 +21466,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 +21488,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 +21539,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 +21678,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 +21835,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 +21857,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");
       }
@@ -21682,32 +22064,32 @@ function crossSpawn(command, options) {
     }
   };
 }
-async function crossWrite(path5, data) {
-  await fsWriteFile(path5, Buffer.from(data));
+async function crossWrite(path6, data) {
+  await fsWriteFile(path6, 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 +22124,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 +22141,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 +22154,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 +22165,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 +22190,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 +22274,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 +22325,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 +22334,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 +22479,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 +22491,7 @@ function getRuntimeAgentNames(config) {
   return [...unique];
 }
 function resolveRuntimeAgentName(config, agentName) {
-  const normalized = normalizeAgentName(agentName);
+  const normalized = normalizeAgentName2(agentName);
   if (!normalized) {
     return normalized;
   }
@@ -22121,7 +22503,7 @@ function resolveRuntimeAgentName(config, agentName) {
     if (!displayName) {
       continue;
     }
-    if (normalizeAgentName(displayName) === normalized) {
+    if (normalizeAgentName2(displayName) === normalized) {
       return internalName;
     }
   }
@@ -22137,7 +22519,7 @@ function createDisplayNameMentionRewriter(config) {
     if (!displayName) {
       continue;
     }
-    const normalizedDisplayName = normalizeAgentName(displayName);
+    const normalizedDisplayName = normalizeAgentName2(displayName);
     if (!normalizedDisplayName || normalizedDisplayName === internalName) {
       continue;
     }
@@ -22447,8 +22829,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 +23159,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 +23292,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 +23352,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 +23448,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 +23486,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 +23504,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 +23663,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 +23688,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 +24081,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 +24169,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 +24362,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 +24388,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 +24599,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 +24623,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 +24632,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 +24662,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 +24757,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 +26427,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 +26529,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 +26569,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 +26581,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 +26607,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 +26619,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 +26645,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 +26909,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 +27435,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 +27639,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 +27704,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 +27785,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 +28014,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 +28025,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 +28125,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 +28230,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 +28498,8 @@ function createBuiltinMcps(disabledMcps = [], websearchConfig) {
 }
 
 // src/multiplexer/tmux/index.ts
+var TMUX_LAYOUT_DEBOUNCE_MS = 150;
+
 class TmuxMultiplexer {
   type = "tmux";
   binaryPath = null;
@@ -28118,6 +28507,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 +28570,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 +28607,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 +28618,74 @@ 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 +28707,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 +29434,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 +29469,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 +29481,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 +29493,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 +29512,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 +29598,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 +29610,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 +29636,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 +29647,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 +29655,7 @@ async function getAstGrepPath() {
   }
   initPromise = (async () => {
     const syncPath = findSgCliPathSync();
-    if (syncPath && existsSync8(syncPath)) {
+    if (syncPath && existsSync9(syncPath)) {
       setSgCliPath(syncPath);
       return syncPath;
     }
@@ -29270,7 +29694,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 +30044,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 +30088,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 +30304,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 +30333,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 +30990,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 +31715,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 +31885,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 +31913,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 +31930,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 +32091,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: {
@@ -32263,6 +32687,7 @@ var OhMyOpenCodeLite = async (ctx) => {
   let taskSessionManagerHook;
   let interviewManager;
   let presetManager;
+  let divoomManager;
   let councilTools;
   let webfetch;
   let rewriteDisplayNameMentions;
@@ -32357,6 +32782,7 @@ var OhMyOpenCodeLite = async (ctx) => {
     });
     interviewManager = createInterviewManager(ctx, config);
     presetManager = createPresetManager(ctx, config);
+    divoomManager = createDivoomManager(config.divoom);
     toolCount = Object.keys(councilTools).length + Object.keys(todoContinuationHook.tool).length + 1 + 2;
   } catch (err) {
     log("[plugin] FATAL: init failed", String(err));
@@ -32393,6 +32819,7 @@ var OhMyOpenCodeLite = async (ctx) => {
       appLog(ctx, "warn", msg).catch(() => {});
     }
   });
+  divoomManager.onPluginLoad();
   return {
     name: "oh-my-opencode-slim",
     agent: agents,
@@ -32625,6 +33052,37 @@ var OhMyOpenCodeLite = async (ctx) => {
       await multiplexerSessionManager.onSessionDeleted(event);
       await interviewManager.handleEvent(input);
       await taskSessionManagerHook.event(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 +33097,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 +33166,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
+        });
+      }
     }
   };
 };