oh-my-opencode 4.1.2 → 4.2.1

package/dist/cli/index.js

@@ -4964,6 +4964,27 @@ var init_plugin_identity = __esm(() => {
 import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
+function rotateLogFileIfNeeded() {
+  try {
+    if (!fs.existsSync(logFile))
+      return;
+    const stats = fs.statSync(logFile);
+    if (stats.size <= maxLogFileSizeBytes)
+      return;
+    const oldest = `${logFile}.${maxLogFileBackups}`;
+    if (fs.existsSync(oldest)) {
+      fs.unlinkSync(oldest);
+    }
+    for (let i2 = maxLogFileBackups - 1;i2 >= 1; i2 -= 1) {
+      const src = `${logFile}.${i2}`;
+      const dst = `${logFile}.${i2 + 1}`;
+      if (fs.existsSync(src)) {
+        fs.renameSync(src, dst);
+      }
+    }
+    fs.renameSync(logFile, `${logFile}.1`);
+  } catch {}
+}
 function flush() {
   if (buffer.length === 0)
     return;
@@ -4971,6 +4992,7 @@ function flush() {
   buffer = [];
   try {
     fs.appendFileSync(logFile, data);
+    rotateLogFileIfNeeded();
   } catch {}
 }
 function scheduleFlush() {
@@ -4994,10 +5016,13 @@ function log(message, data) {
     }
   } catch {}
 }
-var logFile, buffer, flushTimer = null, FLUSH_INTERVAL_MS = 500, BUFFER_SIZE_LIMIT = 50;
+var DEFAULT_MAX_LOG_FILE_SIZE_BYTES, DEFAULT_MAX_LOG_FILE_BACKUPS = 2, logFile, maxLogFileSizeBytes, maxLogFileBackups, buffer, flushTimer = null, FLUSH_INTERVAL_MS = 500, BUFFER_SIZE_LIMIT = 50;
 var init_logger = __esm(() => {
   init_plugin_identity();
+  DEFAULT_MAX_LOG_FILE_SIZE_BYTES = 50 * 1024 * 1024;
   logFile = path.join(os.tmpdir(), LOG_FILENAME);
+  maxLogFileSizeBytes = DEFAULT_MAX_LOG_FILE_SIZE_BYTES;
+  maxLogFileBackups = DEFAULT_MAX_LOG_FILE_BACKUPS;
   buffer = [];
 });
 
@@ -5098,6 +5123,7 @@ function normalizeSDKResponse(response, fallback, options) {
 var usageCacheByClient;
 var init_dynamic_truncator = __esm(() => {
   init_context_limit_resolver();
+  init_logger();
   usageCacheByClient = new WeakMap;
 });
 
@@ -6020,7 +6046,7 @@ var init_main = __esm(() => {
 });
 
 // src/shared/jsonc-parser.ts
-import { existsSync as existsSync2, readFileSync } from "fs";
+import { existsSync as existsSync3, readFileSync } from "fs";
 import { join as join4 } from "path";
 function stripBom(content) {
   return content.charCodeAt(0) === 65279 ? content.slice(1) : content;
@@ -6041,10 +6067,10 @@ function parseJsonc(content) {
 function detectConfigFile(basePath) {
   const jsoncPath = `${basePath}.jsonc`;
   const jsonPath = `${basePath}.json`;
-  if (existsSync2(jsoncPath)) {
+  if (existsSync3(jsoncPath)) {
     return { format: "jsonc", path: jsoncPath };
   }
-  if (existsSync2(jsonPath)) {
+  if (existsSync3(jsonPath)) {
     return { format: "json", path: jsonPath };
   }
   return { format: "none", path: jsonPath };
@@ -6317,8 +6343,8 @@ var init_tolerant_fsync = __esm(() => {
 import {
   closeSync,
   openSync,
-  renameSync,
-  unlinkSync,
+  renameSync as renameSync2,
+  unlinkSync as unlinkSync2,
   writeFileSync
 } from "fs";
 function writeFileAtomically(filePath, content, deps = {}) {
@@ -6331,13 +6357,13 @@ function writeFileAtomically(filePath, content, deps = {}) {
     closeSync(tempFileDescriptor);
   }
   try {
-    renameSync(tempPath, filePath);
+    renameSync2(tempPath, filePath);
   } catch (error) {
     const isWindows = process.platform === "win32";
     const isPermissionError = error instanceof Error && (error.message.includes("EPERM") || error.message.includes("EACCES"));
     if (isWindows && isPermissionError) {
-      unlinkSync(filePath);
-      renameSync(tempPath, filePath);
+      unlinkSync2(filePath);
+      renameSync2(tempPath, filePath);
     } else {
       throw error;
     }
@@ -6573,7 +6599,7 @@ var init_migration = __esm(() => {
 });
 
 // src/shared/opencode-config-dir.ts
-import { existsSync as existsSync4, realpathSync as realpathSync3 } from "fs";
+import { existsSync as existsSync5, realpathSync as realpathSync3 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join5, resolve as resolve2, win32 } from "path";
 function isDevBuild(version) {
@@ -6599,7 +6625,7 @@ function getTauriConfigDir(identifier) {
 }
 function resolveConfigPath(pathValue) {
   const resolvedPath = resolve2(pathValue);
-  if (!existsSync4(resolvedPath))
+  if (!existsSync5(resolvedPath))
     return resolvedPath;
   try {
     return realpathSync3(resolvedPath);
@@ -6627,7 +6653,7 @@ function getOpenCodeConfigDir(options) {
     const legacyDir = getCliConfigDir();
     const legacyConfig = join5(legacyDir, "opencode.json");
     const legacyConfigC = join5(legacyDir, "opencode.jsonc");
-    if (existsSync4(legacyConfig) || existsSync4(legacyConfigC)) {
+    if (existsSync5(legacyConfig) || existsSync5(legacyConfigC)) {
       return legacyDir;
     }
   }
@@ -6669,7 +6695,7 @@ var init_resolve_agent_definition_paths = __esm(() => {
 
 // src/shared/opencode-version.ts
 import { execSync } from "child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync4, realpathSync as realpathSync4 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync4, realpathSync as realpathSync4 } from "fs";
 import { dirname as dirname3, join as join6 } from "path";
 function parseVersion(version) {
   const cleaned = version.replace(/^v/, "").split("-")[0];
@@ -6764,14 +6790,14 @@ var init_opencode_version = __esm(() => {
         return envPath;
       return globalThis.Bun?.which("opencode") ?? null;
     },
-    exists: existsSync5,
+    exists: existsSync6,
     realpath: realpathSync4,
     readText: (filePath) => readFileSync4(filePath, "utf-8")
   };
 });
 
 // src/shared/opencode-storage-detection.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { join as join7 } from "path";
 function isSqliteBackend() {
   if (cachedResult === true)
@@ -6781,7 +6807,7 @@ function isSqliteBackend() {
   const check = () => {
     const versionOk = isOpenCodeVersionAtLeast(OPENCODE_SQLITE_VERSION);
     const dbPath = join7(getDataDir(), "opencode", "opencode.db");
-    return versionOk && existsSync6(dbPath);
+    return versionOk && existsSync7(dbPath);
   };
   if (cachedResult === FALSE_PENDING_RETRY) {
     const result2 = check();
@@ -6967,11 +6993,11 @@ var init_bun_file_shim = __esm(() => {
 });
 
 // src/shared/binary-downloader.ts
-import { chmodSync, existsSync as existsSync7, mkdirSync as mkdirSync3, unlinkSync as unlinkSync2 } from "fs";
+import { chmodSync, existsSync as existsSync8, mkdirSync as mkdirSync3, unlinkSync as unlinkSync3 } from "fs";
 import * as path5 from "path";
 function getCachedBinaryPath(cacheDir, binaryName) {
   const binaryPath = path5.join(cacheDir, binaryName);
-  return existsSync7(binaryPath) ? binaryPath : null;
+  return existsSync8(binaryPath) ? binaryPath : null;
 }
 var init_binary_downloader = __esm(() => {
   init_bun_spawn_shim();
@@ -7426,7 +7452,7 @@ function normalizeModelID(modelID) {
 }
 
 // src/shared/json-file-cache-store.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
 import { join as join9 } from "path";
 function toLogLabel(cacheLabel) {
   return cacheLabel.toLowerCase();
@@ -7439,7 +7465,7 @@ function createJsonFileCacheStore(options) {
   }
   function ensureCacheDir() {
     const cacheDir = options.getCacheDir();
-    if (!existsSync8(cacheDir)) {
+    if (!existsSync9(cacheDir)) {
       mkdirSync4(cacheDir, { recursive: true });
     }
   }
@@ -7448,7 +7474,7 @@ function createJsonFileCacheStore(options) {
       return memoryValue;
     }
     const cacheFile = getCacheFilePath();
-    if (!existsSync8(cacheFile)) {
+    if (!existsSync9(cacheFile)) {
       memoryValue = null;
       log(`[${options.logPrefix}] ${options.cacheLabel} file not found`, { cacheFile });
       return null;
@@ -7474,7 +7500,7 @@ function createJsonFileCacheStore(options) {
     if (writtenInCurrentProcess) {
       return true;
     }
-    return existsSync8(getCacheFilePath());
+    return existsSync9(getCacheFilePath());
   }
   function write(value) {
     ensureCacheDir();
@@ -7650,14 +7676,14 @@ var init_connected_providers_cache = __esm(() => {
 });
 
 // src/shared/model-availability.ts
-import { existsSync as existsSync9, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync6 } from "fs";
 import { join as join10 } from "path";
 function isModelCacheAvailable() {
   if (hasProviderModelsCache()) {
     return true;
   }
   const cacheFile = join10(getOpenCodeCacheDir(), "models.json");
-  return existsSync9(cacheFile);
+  return existsSync10(cacheFile);
 }
 var init_model_availability = __esm(() => {
   init_logger();
@@ -50834,7 +50860,7 @@ var init_opencode_storage_paths = __esm(() => {
 });
 
 // src/shared/compaction-marker.ts
-import { existsSync as existsSync10, readdirSync, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync11, readdirSync, readFileSync as readFileSync7 } from "fs";
 import { join as join12 } from "path";
 function isCompactionPart(part) {
   return typeof part === "object" && part !== null && part.type === "compaction";
@@ -50856,7 +50882,7 @@ function hasCompactionPartInStorage(messageID) {
     return false;
   }
   const partDir = getCompactionPartStorageDir(messageID);
-  if (!existsSync10(partDir)) {
+  if (!existsSync11(partDir)) {
     return false;
   }
   try {
@@ -50895,23 +50921,23 @@ var init_hook_message_injector = __esm(() => {
 });
 
 // src/shared/opencode-message-dir.ts
-import { existsSync as existsSync11, readdirSync as readdirSync2 } from "fs";
+import { existsSync as existsSync12, readdirSync as readdirSync2 } from "fs";
 import { join as join13 } from "path";
 function getMessageDir(sessionID) {
   if (!sessionID.startsWith("ses_"))
     return null;
   if (/[/\\]|\.\./.test(sessionID))
     return null;
-  if (!existsSync11(MESSAGE_STORAGE))
+  if (!existsSync12(MESSAGE_STORAGE))
     return null;
   const directPath = join13(MESSAGE_STORAGE, sessionID);
-  if (existsSync11(directPath)) {
+  if (existsSync12(directPath)) {
     return directPath;
   }
   try {
     for (const dir of readdirSync2(MESSAGE_STORAGE)) {
       const sessionPath = join13(MESSAGE_STORAGE, dir, sessionID);
-      if (existsSync11(sessionPath)) {
+      if (existsSync12(sessionPath)) {
         return sessionPath;
       }
     }
@@ -50963,26 +50989,41 @@ var init_pane_dimensions = __esm(() => {
   init_tmux_path_resolver();
 });
 
+// src/shared/tmux/tmux-utils/pane-command.ts
+var init_pane_command = () => {};
+
 // src/shared/tmux/tmux-utils/pane-spawn.ts
 var init_pane_spawn = __esm(() => {
   init_tmux_path_resolver();
   init_server_health();
+  init_pane_command();
 });
 // src/shared/tmux/tmux-utils/pane-replace.ts
 var init_pane_replace = __esm(() => {
   init_tmux_path_resolver();
+  init_pane_command();
+});
+
+// src/shared/tmux/tmux-utils/pane-activate.ts
+var init_pane_activate = __esm(() => {
+  init_tmux_path_resolver();
+  init_logger();
+  init_runner();
+  init_pane_command();
 });
 
 // src/shared/tmux/tmux-utils/window-spawn.ts
 var init_window_spawn = __esm(() => {
   init_tmux_path_resolver();
   init_server_health();
+  init_pane_command();
 });
 
 // src/shared/tmux/tmux-utils/session-spawn.ts
 var init_session_spawn = __esm(() => {
   init_tmux_path_resolver();
   init_server_health();
+  init_pane_command();
 });
 // src/shared/tmux/tmux-utils/stale-session-sweep.ts
 var init_stale_session_sweep = () => {};
@@ -50998,9 +51039,11 @@ var init_tmux_utils = __esm(() => {
   init_pane_dimensions();
   init_pane_spawn();
   init_pane_replace();
+  init_pane_activate();
   init_window_spawn();
   init_session_spawn();
   init_stale_session_sweep();
+  init_pane_command();
   init_layout();
 });
 
@@ -51010,9 +51053,306 @@ var init_tmux = __esm(() => {
   init_runner();
   init_tmux_utils();
 });
+// src/shared/session-idle-settle.ts
+function settleAfterSessionIdle(ms = DEFAULT_SESSION_IDLE_SETTLE_MS) {
+  return ms > 0 ? new Promise((resolve4) => setTimeout(resolve4, ms)) : Promise.resolve();
+}
+function isRecord6(value) {
+  return typeof value === "object" && value !== null;
+}
+function getSessionStatusPayload(response) {
+  if (isRecord6(response) && isRecord6(response.data)) {
+    return response.data;
+  }
+  if (isRecord6(response)) {
+    return response;
+  }
+  return {};
+}
+function isActiveSessionStatusType(statusType) {
+  return ACTIVE_SESSION_STATUSES.has(statusType);
+}
+async function isSessionActive(client, sessionID) {
+  if (typeof client.session?.status !== "function") {
+    return false;
+  }
+  try {
+    const statusResult = await client.session.status();
+    const status = getSessionStatusPayload(statusResult)[sessionID];
+    if (!isRecord6(status)) {
+      return false;
+    }
+    const statusType = status.type;
+    return typeof statusType === "string" && isActiveSessionStatusType(statusType);
+  } catch {
+    return false;
+  }
+}
+var DEFAULT_SESSION_IDLE_SETTLE_MS = 150, ACTIVE_SESSION_STATUSES;
+var init_session_idle_settle = __esm(() => {
+  ACTIVE_SESSION_STATUSES = new Set(["busy", "retry", "running"]);
+});
+
+// src/shared/prompt-async-gate.ts
+function getPromptGateMessagesFetchTimeoutMs() {
+  return promptGateMessagesFetchTimeoutMsForTesting ?? DEFAULT_PROMPT_GATE_MESSAGES_FETCH_TIMEOUT_MS;
+}
+function pruneExpiredReservations(now = Date.now()) {
+  for (const [sessionID, reservation] of promptAsyncReservations) {
+    if (typeof reservation.expiresAt === "number" && reservation.expiresAt <= now) {
+      promptAsyncReservations.delete(sessionID);
+      log("[prompt-async-gate] expired reservation released", {
+        sessionID,
+        source: reservation.source
+      });
+    }
+  }
+}
+function getActiveReservation(sessionID) {
+  pruneExpiredReservations();
+  return promptAsyncReservations.get(sessionID);
+}
+async function withDispatchTimeout(operation, dispatchTimeoutMs, operationName) {
+  if (dispatchTimeoutMs <= 0) {
+    return operation;
+  }
+  let timeoutID;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutID = setTimeout(() => {
+      reject(new Error(`${operationName} timed out after ${dispatchTimeoutMs}ms`));
+    }, dispatchTimeoutMs);
+  });
+  try {
+    return await Promise.race([operation, timeoutPromise]);
+  } finally {
+    if (timeoutID !== undefined) {
+      clearTimeout(timeoutID);
+    }
+  }
+}
+function isRecord7(value) {
+  return typeof value === "object" && value !== null;
+}
+function getPromptQuery(input) {
+  if (!isRecord7(input)) {
+    return { directory: "" };
+  }
+  const query = input.query;
+  if (!isRecord7(query)) {
+    return { directory: "" };
+  }
+  const promptQuery = { directory: "" };
+  if (typeof query.directory === "string") {
+    promptQuery.directory = query.directory;
+  }
+  if (typeof query.limit === "number") {
+    promptQuery.limit = query.limit;
+  }
+  return promptQuery;
+}
+function getMessagesData(response) {
+  if (isRecord7(response) && Array.isArray(response.data)) {
+    return response.data;
+  }
+  return Array.isArray(response) ? response : [];
+}
+function messageRole(message) {
+  if (!isRecord7(message)) {
+    return;
+  }
+  const info = message.info;
+  if (isRecord7(info) && typeof info.role === "string") {
+    return info.role;
+  }
+  return typeof message.role === "string" ? message.role : undefined;
+}
+function partIsWaitingOnTool(part) {
+  if (!isRecord7(part)) {
+    return false;
+  }
+  if (part.type !== "tool" && part.type !== "tool_use") {
+    return false;
+  }
+  const state = part.state;
+  if (!isRecord7(state)) {
+    return false;
+  }
+  return state.status === "pending" || state.status === "running";
+}
+function latestAssistantTurnIsWaitingOnTools(messages) {
+  for (let index = messages.length - 1;index >= 0; index--) {
+    const message = messages[index];
+    const role = messageRole(message);
+    if (role === "assistant") {
+      if (!isRecord7(message) || !Array.isArray(message.parts)) {
+        return false;
+      }
+      return message.parts.some(partIsWaitingOnTool);
+    }
+    if (role === "user") {
+      return false;
+    }
+  }
+  return false;
+}
+async function sessionLatestAssistantIsWaitingOnTools(args) {
+  const session = args.client.session;
+  if (typeof session?.messages !== "function") {
+    return false;
+  }
+  const messages = session.messages.bind(session);
+  try {
+    const response = await withDispatchTimeout(messages({
+      path: { id: args.sessionID },
+      query: getPromptQuery(args.input)
+    }), args.timeoutMs, `[prompt-async-gate] ${args.sessionName} session.messages`);
+    return latestAssistantTurnIsWaitingOnTools(getMessagesData(response));
+  } catch (error) {
+    log("[prompt-async-gate] latest assistant tool-state check failed", {
+      sessionID: args.sessionID,
+      source: args.source,
+      error: String(error)
+    });
+    return false;
+  }
+}
+async function dispatchAfterSessionIdle(args) {
+  const {
+    sessionName,
+    client,
+    sessionID,
+    input,
+    source,
+    settleMs,
+    postDispatchHoldMs,
+    dispatchTimeoutMs,
+    checkStatus,
+    checkToolState,
+    dispatch
+  } = args;
+  const existing = getActiveReservation(sessionID);
+  if (existing) {
+    log(`[prompt-async-gate] ${sessionName} skipped because session is reserved`, {
+      sessionID,
+      source,
+      reservedBy: existing.source,
+      reservedAgeMs: Date.now() - existing.reservedAt
+    });
+    return { status: "reserved", reservedBy: existing.source };
+  }
+  const reservation = {
+    source,
+    reservedAt: Date.now(),
+    token: Symbol(source)
+  };
+  promptAsyncReservations.set(sessionID, reservation);
+  let dispatchAttempted = false;
+  try {
+    const canReadStatus = checkStatus && typeof client.session?.status === "function";
+    if (settleMs > 0) {
+      await settleAfterSessionIdle(settleMs);
+    }
+    let sessionActive = false;
+    if (canReadStatus) {
+      try {
+        sessionActive = await withDispatchTimeout(isSessionActive(client, sessionID), Math.min(dispatchTimeoutMs, 5000), `[prompt-async-gate] ${sessionName} isSessionActive`);
+      } catch {
+        sessionActive = false;
+      }
+    }
+    if (sessionActive) {
+      log(`[prompt-async-gate] ${sessionName} skipped because session is active`, { sessionID, source });
+      return { status: "active" };
+    }
+    if (checkToolState && typeof client.session?.messages === "function" && await sessionLatestAssistantIsWaitingOnTools({
+      client,
+      sessionID,
+      input,
+      sessionName,
+      source,
+      timeoutMs: Math.min(dispatchTimeoutMs, getPromptGateMessagesFetchTimeoutMs())
+    })) {
+      log(`[prompt-async-gate] ${sessionName} skipped because latest assistant is waiting on tools`, {
+        sessionID,
+        source
+      });
+      return { status: "active" };
+    }
+    log(`[prompt-async-gate] ${sessionName} dispatching`, { sessionID, source });
+    dispatchAttempted = true;
+    const response = await withDispatchTimeout(dispatch(input), dispatchTimeoutMs, `[prompt-async-gate] ${sessionName} dispatch`);
+    log(`[prompt-async-gate] ${sessionName} dispatched`, { sessionID, source });
+    return { status: "dispatched", response };
+  } catch (error) {
+    log(`[prompt-async-gate] ${sessionName} failed`, { sessionID, source, error: String(error) });
+    return { status: "failed", error };
+  } finally {
+    const current = promptAsyncReservations.get(sessionID);
+    if (current?.token === reservation.token) {
+      if (dispatchAttempted && postDispatchHoldMs > 0) {
+        reservation.expiresAt = Date.now() + postDispatchHoldMs;
+      } else {
+        promptAsyncReservations.delete(sessionID);
+      }
+    }
+  }
+}
+async function dispatchInternalPrompt(args) {
+  const {
+    client,
+    sessionID,
+    input,
+    source,
+    settleMs = DEFAULT_SESSION_IDLE_SETTLE_MS
+  } = args;
+  const postDispatchHoldMs = args.postDispatchHoldMs ?? DEFAULT_PROMPT_ASYNC_POST_DISPATCH_HOLD_MS;
+  const dispatchTimeoutMs = args.dispatchTimeoutMs ?? DEFAULT_PROMPT_DISPATCH_TIMEOUT_MS;
+  const sessionName = args.mode === "async" ? "promptAsync" : "prompt";
+  const dispatch = (() => {
+    if (args.mode === "async") {
+      const session2 = args.client.session;
+      if (typeof session2?.promptAsync !== "function") {
+        return;
+      }
+      const dispatchPromptAsync = session2.promptAsync.bind(session2);
+      return (dispatchInput) => dispatchPromptAsync(dispatchInput);
+    }
+    const session = args.client.session;
+    if (typeof session?.prompt !== "function") {
+      return;
+    }
+    const dispatchPrompt = session.prompt.bind(session);
+    return (dispatchInput) => dispatchPrompt(dispatchInput);
+  })();
+  if (!dispatch) {
+    log(`[prompt-async-gate] ${sessionName} unavailable`, { sessionID, source });
+    return { status: "unavailable" };
+  }
+  return dispatchAfterSessionIdle({
+    sessionName,
+    client,
+    sessionID,
+    input,
+    source,
+    settleMs,
+    postDispatchHoldMs,
+    dispatchTimeoutMs,
+    checkStatus: args.checkStatus !== false,
+    checkToolState: args.checkToolState !== false,
+    dispatch
+  });
+}
+var DEFAULT_PROMPT_ASYNC_POST_DISPATCH_HOLD_MS = 250, DEFAULT_PROMPT_DISPATCH_TIMEOUT_MS = 30000, DEFAULT_PROMPT_GATE_MESSAGES_FETCH_TIMEOUT_MS = 5000, promptGateMessagesFetchTimeoutMsForTesting, promptAsyncReservations;
+var init_prompt_async_gate = __esm(() => {
+  init_logger();
+  init_session_idle_settle();
+  promptAsyncReservations = new Map;
+});
+
 // src/shared/model-suggestion-retry.ts
 var init_model_suggestion_retry = __esm(() => {
   init_logger();
+  init_prompt_async_gate();
 });
 
 // src/shared/opencode-server-auth.ts
@@ -51025,7 +51365,7 @@ function getServerBasicAuthHeader() {
   const token = Buffer.from(`${username}:${password}`, "utf8").toString("base64");
   return `Basic ${token}`;
 }
-function isRecord6(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null;
 }
 function isRequestFetch(value) {
@@ -51039,11 +51379,11 @@ function wrapRequestFetch(baseFetch, auth) {
   };
 }
 function getInternalClient(client) {
-  if (!isRecord6(client)) {
+  if (!isRecord8(client)) {
     return null;
   }
   const internal = client["_client"];
-  return isRecord6(internal) ? internal : null;
+  return isRecord8(internal) ? internal : null;
 }
 function tryInjectViaSetConfigHeaders(internal, auth) {
   const setConfig = internal["setConfig"];
@@ -51059,11 +51399,11 @@ function tryInjectViaSetConfigHeaders(internal, auth) {
 }
 function tryInjectViaInterceptors(internal, auth) {
   const interceptors = internal["interceptors"];
-  if (!isRecord6(interceptors)) {
+  if (!isRecord8(interceptors)) {
     return false;
   }
   const requestInterceptors = interceptors["request"];
-  if (!isRecord6(requestInterceptors)) {
+  if (!isRecord8(requestInterceptors)) {
     return false;
   }
   const use = requestInterceptors["use"];
@@ -51085,7 +51425,7 @@ function tryInjectViaFetchWrapper(internal, auth) {
     return false;
   }
   const config = getConfig();
-  if (!isRecord6(config)) {
+  if (!isRecord8(config)) {
     return false;
   }
   const fetchValue = config["fetch"];
@@ -51099,7 +51439,7 @@ function tryInjectViaFetchWrapper(internal, auth) {
 }
 function tryInjectViaMutableInternalConfig(internal, auth) {
   const configValue = internal["_config"];
-  if (!isRecord6(configValue)) {
+  if (!isRecord8(configValue)) {
     return false;
   }
   const fetchValue = configValue["fetch"];
@@ -51110,7 +51450,7 @@ function tryInjectViaMutableInternalConfig(internal, auth) {
   return true;
 }
 function tryInjectViaTopLevelFetch(client, auth) {
-  if (!isRecord6(client)) {
+  if (!isRecord8(client)) {
     return false;
   }
   const fetchValue = client["fetch"];
@@ -51247,11 +51587,11 @@ var init_opencode_command_dirs = __esm(() => {
 });
 
 // src/shared/project-discovery-dirs.ts
-import { existsSync as existsSync12, realpathSync as realpathSync5 } from "fs";
+import { existsSync as existsSync13, realpathSync as realpathSync5 } from "fs";
 import { dirname as dirname4, join as join14, resolve as resolve4 } from "path";
 function normalizePath(path6) {
   const resolvedPath = resolve4(path6);
-  if (!existsSync12(resolvedPath)) {
+  if (!existsSync13(resolvedPath)) {
     return resolvedPath;
   }
   try {
@@ -51267,7 +51607,7 @@ function findProjectOpencodePluginConfigFiles(startDirectory, stopDirectory) {
   const resolvedStopDirectory = stopDirectory ? normalizePath(stopDirectory) : undefined;
   while (true) {
     const opencodeDirectory = join14(currentDirectory, ".opencode");
-    if (existsSync12(opencodeDirectory)) {
+    if (existsSync13(opencodeDirectory)) {
       const detected = detectPluginConfigFile(opencodeDirectory);
       if (detected.format !== "none" && !seen.has(detected.path)) {
         seen.add(detected.path);
@@ -51296,6 +51636,7 @@ var init_session_directory_resolver = () => {};
 // src/shared/session-route.ts
 var init_session_route = __esm(() => {
   init_model_suggestion_retry();
+  init_prompt_async_gate();
 });
 
 // src/shared/session-tools-store.ts
@@ -51462,6 +51803,11 @@ var init_log_legacy_plugin_startup_warning = __esm(() => {
   init_plugin_entry_migrator();
   init_plugin_identity();
 });
+
+// src/shared/legacy-workspace-migration.ts
+var init_legacy_workspace_migration = __esm(() => {
+  init_logger();
+});
 // src/shared/model-string-parser.ts
 var KNOWN_VARIANTS2;
 var init_model_string_parser = __esm(() => {
@@ -51487,6 +51833,7 @@ var init_excluded_dirs = __esm(() => {
     "dist",
     "build",
     ".next",
+    ".omo",
     ".sisyphus",
     ".omx",
     ".turbo",
@@ -51499,7 +51846,6 @@ var init_excluded_dirs = __esm(() => {
   ];
   EXCLUDED_DIRS = Object.freeze(new Set(EXCLUDED_DIR_NAMES));
 });
-
 // src/shared/index.ts
 var init_shared = __esm(() => {
   init_model_resolver();
@@ -51567,6 +51913,7 @@ var init_shared = __esm(() => {
   init_plugin_command_discovery();
   init_plugin_identity();
   init_log_legacy_plugin_startup_warning();
+  init_legacy_workspace_migration();
 });
 
 // src/cli/config-manager/config-context.ts
@@ -51646,17 +51993,17 @@ var init_plugin_name_with_version = __esm(() => {
 });
 
 // src/cli/config-manager/backup-config.ts
-import { copyFileSync as copyFileSync2, existsSync as existsSync13, mkdirSync as mkdirSync5 } from "fs";
+import { copyFileSync as copyFileSync2, existsSync as existsSync14, mkdirSync as mkdirSync5 } from "fs";
 import { dirname as dirname5 } from "path";
 function backupConfigFile(configPath) {
-  if (!existsSync13(configPath)) {
+  if (!existsSync14(configPath)) {
     return { success: true };
   }
   const timestamp2 = new Date().toISOString().replace(/[:.]/g, "-");
   const backupPath = `${configPath}.backup-${timestamp2}`;
   try {
     const dir = dirname5(backupPath);
-    if (!existsSync13(dir)) {
+    if (!existsSync14(dir)) {
       mkdirSync5(dir, { recursive: true });
     }
     copyFileSync2(configPath, backupPath);
@@ -51671,10 +52018,10 @@ function backupConfigFile(configPath) {
 var init_backup_config = () => {};
 
 // src/cli/config-manager/ensure-config-directory-exists.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync6 } from "fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync6 } from "fs";
 function ensureConfigDirectoryExists() {
   const configDir = getConfigDir();
-  if (!existsSync14(configDir)) {
+  if (!existsSync15(configDir)) {
     mkdirSync6(configDir, { recursive: true });
   }
 }
@@ -51712,14 +52059,14 @@ function formatErrorWithSuggestion(err, context) {
 }
 
 // src/cli/config-manager/opencode-config-format.ts
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 function detectConfigFormat() {
   const configJsonc = getConfigJsonc();
   const configJson = getConfigJson();
-  if (existsSync15(configJsonc)) {
+  if (existsSync16(configJsonc)) {
     return { format: "jsonc", path: configJsonc };
   }
-  if (existsSync15(configJson)) {
+  if (existsSync16(configJson)) {
     return { format: "json", path: configJson };
   }
   return { format: "none", path: configJson };
@@ -51729,13 +52076,13 @@ var init_opencode_config_format = __esm(() => {
 });
 
 // src/cli/config-manager/parse-opencode-config-file.ts
-import { readFileSync as readFileSync8, statSync } from "fs";
+import { readFileSync as readFileSync8, statSync as statSync2 } from "fs";
 function isEmptyOrWhitespace(content) {
   return content.trim().length === 0;
 }
 function parseOpenCodeConfigFileWithError(path6) {
   try {
-    const stat = statSync(path6);
+    const stat = statSync2(path6);
     if (stat.size === 0) {
       return { config: null, error: `Config file is empty: ${path6}. Delete it or add valid JSON content.` };
     }
@@ -52262,7 +52609,7 @@ var init_generate_omo_config = __esm(() => {
 });
 
 // src/shared/migrate-legacy-config-file.ts
-import { existsSync as existsSync16, readFileSync as readFileSync10, renameSync as renameSync2, rmSync } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync10, renameSync as renameSync3, rmSync } from "fs";
 import { join as join15, dirname as dirname6, basename as basename2 } from "path";
 function buildCanonicalPath(legacyPath) {
   const dir = dirname6(legacyPath);
@@ -52272,7 +52619,7 @@ function buildCanonicalPath(legacyPath) {
 function archiveLegacyConfigFile(legacyPath) {
   const backupPath = `${legacyPath}.bak`;
   try {
-    renameSync2(legacyPath, backupPath);
+    renameSync3(legacyPath, backupPath);
     log("[migrateLegacyConfigFile] Legacy config was migrated and renamed to backup. Update the canonical file only.", {
       legacyPath,
       backupPath
@@ -52300,10 +52647,10 @@ function archiveLegacyConfigFile(legacyPath) {
 }
 function migrateLegacySidecarFile(legacyPath, canonicalPath) {
   const legacySidecarPath = getSidecarPath(legacyPath);
-  if (!existsSync16(legacySidecarPath))
+  if (!existsSync17(legacySidecarPath))
     return true;
   const canonicalSidecarPath = getSidecarPath(canonicalPath);
-  if (existsSync16(canonicalSidecarPath))
+  if (existsSync17(canonicalSidecarPath))
     return true;
   try {
     const content = readFileSync10(legacySidecarPath, "utf-8");
@@ -52323,12 +52670,12 @@ function migrateLegacySidecarFile(legacyPath, canonicalPath) {
   }
 }
 function migrateLegacyConfigFile(legacyPath) {
-  if (!existsSync16(legacyPath))
+  if (!existsSync17(legacyPath))
     return false;
   if (!basename2(legacyPath).startsWith(LEGACY_CONFIG_BASENAME))
     return false;
   const canonicalPath = buildCanonicalPath(legacyPath);
-  if (existsSync16(canonicalPath))
+  if (existsSync17(canonicalPath))
     return false;
   try {
     const content = readFileSync10(legacyPath, "utf-8");
@@ -52372,7 +52719,7 @@ function deepMergeRecord(target, source) {
 }
 
 // src/cli/config-manager/write-omo-config.ts
-import { existsSync as existsSync17, readFileSync as readFileSync11, statSync as statSync2, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync11, statSync as statSync3, writeFileSync as writeFileSync4 } from "fs";
 import { basename as basename3, dirname as dirname7, extname, join as join16 } from "path";
 function isEmptyOrWhitespace2(content) {
   return content.trim().length === 0;
@@ -52390,10 +52737,10 @@ function writeOmoConfig(installConfig) {
   const detectedConfigPath = getOmoConfigPath();
   const canonicalConfigPath = join16(dirname7(detectedConfigPath), `${CONFIG_BASENAME}${extname(detectedConfigPath) || ".json"}`);
   const shouldMigrateLegacyPath = basename3(detectedConfigPath).startsWith(LEGACY_CONFIG_BASENAME);
-  const omoConfigPath = shouldMigrateLegacyPath ? migrateLegacyConfigFile(detectedConfigPath) || existsSync17(canonicalConfigPath) ? canonicalConfigPath : detectedConfigPath : detectedConfigPath;
+  const omoConfigPath = shouldMigrateLegacyPath ? migrateLegacyConfigFile(detectedConfigPath) || existsSync18(canonicalConfigPath) ? canonicalConfigPath : detectedConfigPath : detectedConfigPath;
   try {
     const newConfig = generateOmoConfig(installConfig);
-    if (existsSync17(omoConfigPath)) {
+    if (existsSync18(omoConfigPath)) {
       const backupResult = backupConfigFile(omoConfigPath);
       if (!backupResult.success) {
         return {
@@ -52403,7 +52750,7 @@ function writeOmoConfig(installConfig) {
         };
       }
       try {
-        const stat = statSync2(omoConfigPath);
+        const stat = statSync3(omoConfigPath);
         const content = readFileSync11(omoConfigPath, "utf-8");
         if (stat.size === 0 || isEmptyOrWhitespace2(content)) {
           writeFileSync4(omoConfigPath, JSON.stringify(newConfig, null, 2) + `
@@ -52600,10 +52947,10 @@ var init_opencode_binary = __esm(() => {
 });
 
 // src/cli/config-manager/detect-current-config.ts
-import { existsSync as existsSync18, readFileSync as readFileSync12 } from "fs";
+import { existsSync as existsSync19, readFileSync as readFileSync12 } from "fs";
 function detectProvidersFromOmoConfig() {
   const omoConfigPath = getOmoConfigPath();
-  if (!existsSync18(omoConfigPath)) {
+  if (!existsSync19(omoConfigPath)) {
     return {
       hasOpenAI: true,
       hasOpencodeZen: true,
@@ -52703,7 +53050,7 @@ var init_detect_current_config = __esm(() => {
 });
 
 // src/cli/config-manager/bun-install.ts
-import { existsSync as existsSync19 } from "fs";
+import { existsSync as existsSync20 } from "fs";
 import { join as join17 } from "path";
 function getDefaultWorkspaceDir() {
   return join17(getOpenCodeCacheDir(), "packages");
@@ -52732,7 +53079,7 @@ async function runBunInstallWithDetails(options) {
   const outputMode = options?.outputMode ?? "pipe";
   const cacheDir = options?.workspaceDir ?? getDefaultWorkspaceDir();
   const packageJsonPath = `${cacheDir}/package.json`;
-  if (!existsSync19(packageJsonPath)) {
+  if (!existsSync20(packageJsonPath)) {
     return {
       success: false,
       error: `Workspace not initialized: ${packageJsonPath} not found. OpenCode should create this on first run.`
@@ -53530,17 +53877,21 @@ function readPackageVersion(packageJsonPath) {
   const pkg = JSON.parse(content);
   return pkg.version ?? null;
 }
-function getCachedVersion() {
+function getCachedVersion(options = {}) {
+  const packageJsonCandidates = options.packageJsonCandidates ?? INSTALLED_PACKAGE_JSON_CANDIDATES;
+  const findPackageJson = options.findPackageJson ?? findPackageJsonUp;
   try {
-    const currentDir = path10.dirname(fileURLToPath2(import.meta.url));
-    const pkgPath = findPackageJsonUp(currentDir);
-    if (pkgPath) {
-      return readPackageVersion(pkgPath);
+    const currentDir = options.currentDir === undefined ? path10.dirname(fileURLToPath2(import.meta.url)) : options.currentDir;
+    if (currentDir) {
+      const pkgPath = findPackageJson(currentDir);
+      if (pkgPath) {
+        return readPackageVersion(pkgPath);
+      }
     }
   } catch (err) {
     log("[auto-update-checker] Failed to resolve version from current directory:", err);
   }
-  for (const candidate of INSTALLED_PACKAGE_JSON_CANDIDATES) {
+  for (const candidate of packageJsonCandidates) {
     try {
       if (fs9.existsSync(candidate)) {
         return readPackageVersion(candidate);
@@ -53548,10 +53899,12 @@ function getCachedVersion() {
     } catch {}
   }
   try {
-    const execDir = path10.dirname(fs9.realpathSync(process.execPath));
-    const pkgPath = findPackageJsonUp(execDir);
-    if (pkgPath) {
-      return readPackageVersion(pkgPath);
+    const execDir = options.execDir === undefined ? path10.dirname(fs9.realpathSync(process.execPath)) : options.execDir;
+    if (execDir) {
+      const pkgPath = findPackageJson(execDir);
+      if (pkgPath) {
+        return readPackageVersion(pkgPath);
+      }
     }
   } catch (err) {
     log("[auto-update-checker] Failed to resolve version from execPath:", err);
@@ -53800,17 +54153,22 @@ import * as path12 from "path";
 function stripTrailingCommas(json3) {
   return json3.replace(/,(\s*[}\]])/g, "$1");
 }
-function removeFromTextBunLock(lockPath, packageName) {
+function removeFromTextBunLock(lockPath, packageNames) {
   try {
     const content = fs11.readFileSync(lockPath, "utf-8");
     const lock = JSON.parse(stripTrailingCommas(content));
-    if (lock.packages?.[packageName]) {
-      delete lock.packages[packageName];
+    let removed = false;
+    for (const packageName of packageNames) {
+      if (lock.packages?.[packageName]) {
+        delete lock.packages[packageName];
+        log(`[auto-update-checker] Removed from bun.lock: ${packageName}`);
+        removed = true;
+      }
+    }
+    if (removed) {
       fs11.writeFileSync(lockPath, JSON.stringify(lock, null, 2));
-      log(`[auto-update-checker] Removed from bun.lock: ${packageName}`);
-      return true;
     }
-    return false;
+    return removed;
   } catch {
     return false;
   }
@@ -53824,26 +54182,57 @@ function deleteBinaryBunLock(lockPath) {
     return false;
   }
 }
-function removeFromBunLock(packageName) {
-  const textLockPath = path12.join(CACHE_DIR, "bun.lock");
-  const binaryLockPath = path12.join(CACHE_DIR, "bun.lockb");
+function removeFromBunLock(cacheDir, packageNames) {
+  const textLockPath = path12.join(cacheDir, "bun.lock");
+  const binaryLockPath = path12.join(cacheDir, "bun.lockb");
   if (fs11.existsSync(textLockPath)) {
-    return removeFromTextBunLock(textLockPath, packageName);
+    return removeFromTextBunLock(textLockPath, packageNames);
   }
   if (fs11.existsSync(binaryLockPath)) {
     return deleteBinaryBunLock(binaryLockPath);
   }
   return false;
 }
-function invalidatePackage(packageName = PACKAGE_NAME2) {
+function getInvalidationPackageNames(packageName, defaultPackageName, acceptedPackageNames) {
+  if (packageName === defaultPackageName) {
+    return acceptedPackageNames;
+  }
+  return [packageName];
+}
+function removeSpecifierRootDirs(cacheDir, packageNames) {
+  const parentDirs = [cacheDir, path12.join(cacheDir, "packages")];
+  const prefixes = packageNames.map((packageName) => `${packageName}@`);
+  let removed = false;
+  for (const parentDir of parentDirs) {
+    if (!fs11.existsSync(parentDir)) {
+      continue;
+    }
+    for (const entry of fs11.readdirSync(parentDir, { withFileTypes: true })) {
+      if (!entry.isDirectory() || !prefixes.some((prefix) => entry.name.startsWith(prefix))) {
+        continue;
+      }
+      const specifierDir = path12.join(parentDir, entry.name);
+      fs11.rmSync(specifierDir, { recursive: true, force: true });
+      log(`[auto-update-checker] Specifier cache removed: ${specifierDir}`);
+      removed = true;
+    }
+  }
+  return removed;
+}
+function invalidatePackage(packageName = PACKAGE_NAME2, options = {}) {
   try {
-    const userConfigDir = getUserConfigDir();
-    const pkgDirs = [
-      path12.join(userConfigDir, "node_modules", packageName),
-      path12.join(CACHE_DIR, "node_modules", packageName)
-    ];
+    const acceptedPackageNames = options.acceptedPackageNames ?? ACCEPTED_PACKAGE_NAMES2;
+    const cacheDir = options.cacheDir ?? CACHE_DIR;
+    const defaultPackageName = options.defaultPackageName ?? PACKAGE_NAME2;
+    const userConfigDir = options.userConfigDir ?? getUserConfigDir();
+    const packageNames = getInvalidationPackageNames(packageName, defaultPackageName, acceptedPackageNames);
+    const pkgDirs = packageNames.flatMap((name) => [
+      path12.join(userConfigDir, "node_modules", name),
+      path12.join(cacheDir, "node_modules", name)
+    ]);
     let packageRemoved = false;
     let lockRemoved = false;
+    let specifierRemoved = false;
     for (const pkgDir of pkgDirs) {
       if (fs11.existsSync(pkgDir)) {
         fs11.rmSync(pkgDir, { recursive: true, force: true });
@@ -53851,8 +54240,9 @@ function invalidatePackage(packageName = PACKAGE_NAME2) {
         packageRemoved = true;
       }
     }
-    lockRemoved = removeFromBunLock(packageName);
-    if (!packageRemoved && !lockRemoved) {
+    specifierRemoved = removeSpecifierRootDirs(cacheDir, packageNames);
+    lockRemoved = removeFromBunLock(cacheDir, packageNames);
+    if (!packageRemoved && !specifierRemoved && !lockRemoved) {
       log(`[auto-update-checker] Package not found, nothing to invalidate: ${packageName}`);
       return false;
     }
@@ -53900,7 +54290,7 @@ var init_update_toasts = __esm(() => {
 });
 
 // src/hooks/auto-update-checker/hook/background-update-check.ts
-import { existsSync as existsSync32 } from "fs";
+import { existsSync as existsSync33 } from "fs";
 import { join as join30 } from "path";
 function getCacheWorkspaceDir(deps) {
   return deps.join(deps.getOpenCodeCacheDir(), "packages");
@@ -53951,7 +54341,7 @@ async function primeCacheWorkspace(activeWorkspace, deps) {
   return runBunInstallSafe(cacheWorkspace, deps);
 }
 function createBackgroundUpdateCheckRunner(overrides = {}) {
-  const deps = { ...defaultDeps2, ...overrides };
+  const deps = { ...defaultDeps3, ...overrides };
   return async function runBackgroundUpdateCheck(ctx, autoUpdate, getToastMessage) {
     const pluginInfo = deps.findPluginEntry(ctx.directory);
     if (!pluginInfo) {
@@ -54009,7 +54399,7 @@ function createBackgroundUpdateCheckRunner(overrides = {}) {
     deps.log("[auto-update-checker] bun install failed; update not installed (falling back to notification-only)");
   };
 }
-var defaultDeps2, runBackgroundUpdateCheck;
+var defaultDeps3, runBackgroundUpdateCheck;
 var init_background_update_check = __esm(() => {
   init_config_manager();
   init_logger();
@@ -54018,8 +54408,8 @@ var init_background_update_check = __esm(() => {
   init_constants3();
   init_checker();
   init_update_toasts();
-  defaultDeps2 = {
-    existsSync: existsSync32,
+  defaultDeps3 = {
+    existsSync: existsSync33,
     join: join30,
     runBunInstallWithDetails,
     log,
@@ -54205,7 +54595,7 @@ var init_startup_toasts = __esm(() => {
 });
 
 // src/hooks/auto-update-checker/hook.ts
-function createAutoUpdateCheckerHook(ctx, options = {}, deps = defaultDeps3) {
+function createAutoUpdateCheckerHook(ctx, options = {}, deps = defaultDeps4) {
   const {
     showStartupToast = true,
     isSisyphusEnabled = false,
@@ -54262,13 +54652,13 @@ v${latestVersion} available. Restart OpenCode to apply.` : "OpenCode is now on S
     }
   };
 }
-var defaultDeps3, isRecord7 = (value) => {
+var defaultDeps4, isRecord9 = (value) => {
   return typeof value === "object" && value !== null;
 }, getParentID = (properties) => {
-  if (!isRecord7(properties))
+  if (!isRecord9(properties))
     return;
   const { info } = properties;
-  if (!isRecord7(info))
+  if (!isRecord9(info))
     return;
   const { parentID } = info;
   return typeof parentID === "string" && parentID.length > 0 ? parentID : undefined;
@@ -54282,7 +54672,7 @@ var init_hook = __esm(() => {
   init_model_capabilities_status();
   init_model_cache_warning();
   init_startup_toasts();
-  defaultDeps3 = {
+  defaultDeps4 = {
     getCachedVersion,
     getLocalDevVersion,
     showConfigErrorsIfAny,
@@ -54332,7 +54722,7 @@ var {
 // package.json
 var package_default = {
   name: "oh-my-opencode",
-  version: "4.1.2",
+  version: "4.2.1",
   description: "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   main: "./dist/index.js",
   types: "dist/index.d.ts",
@@ -54344,7 +54734,8 @@ var package_default = {
   files: [
     "dist",
     "bin",
-    "postinstall.mjs"
+    "postinstall.mjs",
+    "packages/lsp-tools-mcp/dist"
   ],
   exports: {
     ".": {
@@ -54355,6 +54746,7 @@ var package_default = {
   },
   scripts: {
     build: "bun build src/index.ts --outdir dist --target bun --format esm --external @ast-grep/napi --external zod && bun run build:node-require-shim && tsc --emitDeclarationOnly && bun build src/cli/index.ts --outdir dist/cli --target bun --format esm --external @ast-grep/napi && bun run build:schema",
+    "build:lsp-tools-mcp": "npm --prefix packages/lsp-tools-mcp ci && npm --prefix packages/lsp-tools-mcp run build",
     "build:node-require-shim": "bun run script/patch-node-require-shim.ts",
     "build:all": "bun run build && bun run build:binaries",
     "build:binaries": "bun run script/build-binaries.ts",
@@ -54363,11 +54755,11 @@ var package_default = {
     clean: "rm -rf dist",
     prepare: "bun run build",
     postinstall: "node postinstall.mjs",
-    prepublishOnly: "bun run clean && bun run build",
+    prepublishOnly: "bun run clean && bun run build:lsp-tools-mcp && bun run build",
     "test:model-capabilities": "bun test src/shared/model-capability-aliases.test.ts src/shared/model-capability-guardrails.test.ts src/shared/model-capabilities.test.ts src/cli/doctor/checks/model-resolution.test.ts --bail",
     typecheck: "tsgo --noEmit",
     "typecheck:script": "tsgo --noEmit -p script/tsconfig.json",
-    test: "bun run script/run-ci-tests.ts"
+    test: "bun test"
   },
   keywords: [
     "opencode",
@@ -54392,7 +54784,7 @@ var package_default = {
     "@ast-grep/cli": "^0.41.1",
     "@ast-grep/napi": "^0.41.1",
     "@clack/prompts": "^0.11.0",
-    "@code-yeongyu/comment-checker": "^0.7.0",
+    "@code-yeongyu/comment-checker": "^0.7.1",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@opencode-ai/plugin": "^1.4.0",
     "@opencode-ai/sdk": "^1.4.0",
@@ -54415,17 +54807,17 @@ var package_default = {
     zod: "^4.4.3"
   },
   optionalDependencies: {
-    "oh-my-opencode-darwin-arm64": "4.1.2",
-    "oh-my-opencode-darwin-x64": "4.1.2",
-    "oh-my-opencode-darwin-x64-baseline": "4.1.2",
-    "oh-my-opencode-linux-arm64": "4.1.2",
-    "oh-my-opencode-linux-arm64-musl": "4.1.2",
-    "oh-my-opencode-linux-x64": "4.1.2",
-    "oh-my-opencode-linux-x64-baseline": "4.1.2",
-    "oh-my-opencode-linux-x64-musl": "4.1.2",
-    "oh-my-opencode-linux-x64-musl-baseline": "4.1.2",
-    "oh-my-opencode-windows-x64": "4.1.2",
-    "oh-my-opencode-windows-x64-baseline": "4.1.2"
+    "oh-my-opencode-darwin-arm64": "4.2.1",
+    "oh-my-opencode-darwin-x64": "4.2.1",
+    "oh-my-opencode-darwin-x64-baseline": "4.2.1",
+    "oh-my-opencode-linux-arm64": "4.2.1",
+    "oh-my-opencode-linux-arm64-musl": "4.2.1",
+    "oh-my-opencode-linux-x64": "4.2.1",
+    "oh-my-opencode-linux-x64-baseline": "4.2.1",
+    "oh-my-opencode-linux-x64-musl": "4.2.1",
+    "oh-my-opencode-linux-x64-musl-baseline": "4.2.1",
+    "oh-my-opencode-windows-x64": "4.2.1",
+    "oh-my-opencode-windows-x64-baseline": "4.2.1"
   },
   overrides: {
     hono: "^4.12.18",
@@ -70868,7 +71260,7 @@ var NotificationConfigSchema = exports_external.object({
   force_enable: exports_external.boolean().optional()
 });
 // src/mcp/types.ts
-var McpNameSchema = exports_external.enum(["websearch", "context7", "grep_app"]);
+var McpNameSchema = exports_external.enum(["websearch", "context7", "grep_app", "lsp"]);
 var AnyMcpNameSchema = exports_external.string().min(1);
 
 // src/config/schema/agent-definitions.ts
@@ -71235,7 +71627,10 @@ function loadConfigFromPath(configPath, _ctx) {
       const result = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
       if (result.success) {
         addAgentOrderWarnings(configPath, result.data.agent_order);
-        log(`Config loaded from ${configPath}`, { agents: result.data.agents });
+        log(`Config loaded from ${configPath}`, {
+          agents: result.data.agents,
+          team_mode: result.data.team_mode
+        });
         return result.data;
       }
       const errorMsg = result.error.issues.map((i2) => `${i2.path.join(".")}: ${i2.message}`).join(", ");
@@ -71247,7 +71642,10 @@ function loadConfigFromPath(configPath, _ctx) {
       const partialResult = parseConfigPartially(rawConfig);
       if (partialResult) {
         addAgentOrderWarnings(configPath, partialResult.agent_order);
-        log(`Partial config loaded from ${configPath}`, { agents: partialResult.agents });
+        log(`Partial config loaded from ${configPath}`, {
+          agents: partialResult.agents,
+          team_mode: partialResult.team_mode
+        });
         return partialResult;
       }
       return null;
@@ -71393,6 +71791,7 @@ function loadPluginConfig(directory, ctx) {
   };
   log("Final merged config", {
     agents: config2.agents,
+    team_mode: config2.team_mode,
     disabled_agents: config2.disabled_agents,
     disabled_mcps: config2.disabled_mcps,
     disabled_hooks: config2.disabled_hooks,
@@ -72989,6 +73388,14 @@ async function withWorkingOpencodePath(startServer, finder = findWorkingOpencode
 
 // src/cli/run/server-connection.ts
 var LOOPBACK_HOSTS = new Set(["127.0.0.1", "localhost", "::1", "[::1]", "0.0.0.0"]);
+var defaultDeps2 = {
+  createOpencode,
+  createOpencodeClient,
+  injectServerAuthIntoClient,
+  isPortAvailable,
+  getAvailableServerPort,
+  withWorkingOpencodePath
+};
 function isLoopbackAttachUrl(url2) {
   try {
     const parsed = new URL(url2);
@@ -73009,19 +73416,19 @@ function isPortRangeExhausted(error51) {
   }
   return error51.message.includes("No available port found in range");
 }
-async function startServer(options) {
+async function startServer(options, deps) {
   const { signal, port } = options;
-  const { client: client3, server: server2 } = await withWorkingOpencodePath(() => createOpencode({ signal, port, hostname: "127.0.0.1" }));
+  const { client: client3, server: server2 } = await deps.withWorkingOpencodePath(() => deps.createOpencode({ signal, port, hostname: "127.0.0.1" }));
   console.log(import_picocolors10.default.dim("Server listening at"), import_picocolors10.default.cyan(server2.url));
   return { client: client3, cleanup: () => server2.close() };
 }
-async function createServerConnection(options) {
+async function createServerConnectionWithDeps(options, deps) {
   const { port, attach, signal } = options;
   if (attach !== undefined) {
     console.log(import_picocolors10.default.dim("Attaching to existing server at"), import_picocolors10.default.cyan(attach));
-    const client3 = createOpencodeClient({ baseUrl: attach });
+    const client3 = deps.createOpencodeClient({ baseUrl: attach });
     if (isLoopbackAttachUrl(attach)) {
-      injectServerAuthIntoClient(client3);
+      deps.injectServerAuthIntoClient(client3);
     }
     return { client: client3, cleanup: () => {} };
   }
@@ -73029,47 +73436,47 @@ async function createServerConnection(options) {
     if (port < 1 || port > 65535) {
       throw new Error("Port must be between 1 and 65535");
     }
-    const available = await isPortAvailable(port, "127.0.0.1");
+    const available = await deps.isPortAvailable(port, "127.0.0.1");
     if (available) {
       console.log(import_picocolors10.default.dim("Starting server on port"), import_picocolors10.default.cyan(port.toString()));
       try {
-        return await startServer({ signal, port });
+        return await startServer({ signal, port }, deps);
       } catch (error51) {
         if (!isPortStartFailure(error51, port)) {
           throw error51;
         }
-        const stillAvailable = await isPortAvailable(port, "127.0.0.1");
+        const stillAvailable = await deps.isPortAvailable(port, "127.0.0.1");
         if (stillAvailable) {
           throw error51;
         }
         console.log(import_picocolors10.default.dim("Port"), import_picocolors10.default.cyan(port.toString()), import_picocolors10.default.dim("became occupied, attaching to existing server"));
-        const client4 = createOpencodeClient({ baseUrl: `http://127.0.0.1:${port}` });
-        injectServerAuthIntoClient(client4);
+        const client4 = deps.createOpencodeClient({ baseUrl: `http://127.0.0.1:${port}` });
+        deps.injectServerAuthIntoClient(client4);
         return { client: client4, cleanup: () => {} };
       }
     }
     console.log(import_picocolors10.default.dim("Port"), import_picocolors10.default.cyan(port.toString()), import_picocolors10.default.dim("is occupied, attaching to existing server"));
-    const client3 = createOpencodeClient({ baseUrl: `http://127.0.0.1:${port}` });
-    injectServerAuthIntoClient(client3);
+    const client3 = deps.createOpencodeClient({ baseUrl: `http://127.0.0.1:${port}` });
+    deps.injectServerAuthIntoClient(client3);
     return { client: client3, cleanup: () => {} };
   }
   let selectedPort;
   let wasAutoSelected;
   try {
-    const selected = await getAvailableServerPort(DEFAULT_SERVER_PORT, "127.0.0.1");
+    const selected = await deps.getAvailableServerPort(DEFAULT_SERVER_PORT, "127.0.0.1");
     selectedPort = selected.port;
     wasAutoSelected = selected.wasAutoSelected;
   } catch (error51) {
     if (!isPortRangeExhausted(error51)) {
       throw error51;
     }
-    const defaultPortIsAvailable = await isPortAvailable(DEFAULT_SERVER_PORT, "127.0.0.1");
+    const defaultPortIsAvailable = await deps.isPortAvailable(DEFAULT_SERVER_PORT, "127.0.0.1");
     if (defaultPortIsAvailable) {
       throw error51;
     }
     console.log(import_picocolors10.default.dim("Port range exhausted, attaching to existing server on"), import_picocolors10.default.cyan(DEFAULT_SERVER_PORT.toString()));
-    const client3 = createOpencodeClient({ baseUrl: `http://127.0.0.1:${DEFAULT_SERVER_PORT}` });
-    injectServerAuthIntoClient(client3);
+    const client3 = deps.createOpencodeClient({ baseUrl: `http://127.0.0.1:${DEFAULT_SERVER_PORT}` });
+    deps.injectServerAuthIntoClient(client3);
     return { client: client3, cleanup: () => {} };
   }
   if (wasAutoSelected) {
@@ -73078,16 +73485,19 @@ async function createServerConnection(options) {
     console.log(import_picocolors10.default.dim("Starting server on port"), import_picocolors10.default.cyan(selectedPort.toString()));
   }
   try {
-    return await startServer({ signal, port: selectedPort });
+    return await startServer({ signal, port: selectedPort }, deps);
   } catch (error51) {
     if (!isPortStartFailure(error51, selectedPort)) {
       throw error51;
     }
-    const { port: retryPort } = await getAvailableServerPort(selectedPort + 1, "127.0.0.1");
+    const { port: retryPort } = await deps.getAvailableServerPort(selectedPort + 1, "127.0.0.1");
     console.log(import_picocolors10.default.dim("Retrying server start on port"), import_picocolors10.default.cyan(retryPort.toString()));
-    return await startServer({ signal, port: retryPort });
+    return await startServer({ signal, port: retryPort }, deps);
   }
 }
+async function createServerConnection(options) {
+  return await createServerConnectionWithDeps(options, defaultDeps2);
+}
 
 // src/cli/run/session-resolver.ts
 init_shared();
@@ -73338,13 +73748,13 @@ var import_picocolors14 = __toESM(require_picocolors(), 1);
 init_shared();
 var import_picocolors13 = __toESM(require_picocolors(), 1);
 // src/features/boulder-state/constants.ts
-var BOULDER_DIR = ".sisyphus";
+var BOULDER_DIR = ".omo";
 var BOULDER_FILE = "boulder.json";
 var BOULDER_STATE_PATH = `${BOULDER_DIR}/${BOULDER_FILE}`;
 var NOTEPAD_DIR = "notepads";
 var NOTEPAD_BASE_PATH = `${BOULDER_DIR}/${NOTEPAD_DIR}`;
 // src/features/boulder-state/storage.ts
-import { existsSync as existsSync21, readFileSync as readFileSync14, writeFileSync as writeFileSync5, mkdirSync as mkdirSync7, readdirSync as readdirSync3 } from "fs";
+import { existsSync as existsSync22, readFileSync as readFileSync14, writeFileSync as writeFileSync5, mkdirSync as mkdirSync7, readdirSync as readdirSync3 } from "fs";
 import { basename as basename5, dirname as dirname10, isAbsolute as isAbsolute3, join as join20, relative as relative2, resolve as resolve5 } from "path";
 var RESERVED_KEYS = new Set(["__proto__", "prototype", "constructor"]);
 function parseIsoToMs(value) {
@@ -73424,11 +73834,11 @@ function resolveBoulderPlanPath(directory, state) {
   }
   const absoluteWorktreePath = resolveTrackedPath(directory, worktreePath);
   const worktreePlanPath = resolve5(absoluteWorktreePath, relativePlanPath);
-  return existsSync21(worktreePlanPath) ? worktreePlanPath : absolutePlanPath;
+  return existsSync22(worktreePlanPath) ? worktreePlanPath : absolutePlanPath;
 }
 function readBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
-  if (!existsSync21(filePath)) {
+  if (!existsSync22(filePath)) {
     return null;
   }
   try {
@@ -73471,7 +73881,7 @@ var CHECKED_CHECKBOX_PATTERN = /^(\s*)[-*]\s*\[[xX]\]\s*(.+)$/;
 var TODO_TASK_PATTERN = /^\d+\.\s+/;
 var FINAL_WAVE_TASK_PATTERN = /^F\d+\.\s+/i;
 function getPlanProgress(planPath) {
-  if (!existsSync21(planPath)) {
+  if (!existsSync22(planPath)) {
     return { total: 0, completed: 0, isComplete: false };
   }
   try {
@@ -73550,7 +73960,7 @@ function resolveBoulderPlanPathForWork(directory, work) {
   return resolveBoulderPlanPath(directory, work);
 }
 // src/features/boulder-state/top-level-task.ts
-import { existsSync as existsSync22, readFileSync as readFileSync15 } from "fs";
+import { existsSync as existsSync23, readFileSync as readFileSync15 } from "fs";
 var TODO_HEADING_PATTERN2 = /^##\s+TODOs\b/i;
 var FINAL_VERIFICATION_HEADING_PATTERN2 = /^##\s+Final Verification Wave\b/i;
 var SECOND_LEVEL_HEADING_PATTERN2 = /^##\s+/;
@@ -73573,7 +73983,7 @@ function buildTaskRef(section, taskLabel) {
   };
 }
 function readCurrentTopLevelTask(planPath) {
-  if (!existsSync22(planPath)) {
+  if (!existsSync23(planPath)) {
     return null;
   }
   try {
@@ -73615,16 +74025,16 @@ function getSessionAgent(sessionID) {
   return sessionAgentMap.get(sessionID);
 }
 // src/features/run-continuation-state/constants.ts
-var CONTINUATION_MARKER_DIR = ".sisyphus/run-continuation";
+var CONTINUATION_MARKER_DIR = ".omo/run-continuation";
 // src/features/run-continuation-state/storage.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync8, readFileSync as readFileSync16, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync24, mkdirSync as mkdirSync8, readFileSync as readFileSync16, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "fs";
 import { join as join21 } from "path";
 function getMarkerPath(directory, sessionID) {
   return join21(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
 }
 function readContinuationMarker(directory, sessionID) {
   const markerPath = getMarkerPath(directory, sessionID);
-  if (!existsSync23(markerPath))
+  if (!existsSync24(markerPath))
     return null;
   try {
     const raw = readFileSync16(markerPath, "utf-8");
@@ -73770,11 +74180,11 @@ init_agent_display_names();
 
 // src/hooks/ralph-loop/storage.ts
 init_frontmatter();
-import { existsSync as existsSync24, readFileSync as readFileSync18, writeFileSync as writeFileSync7, unlinkSync as unlinkSync3, mkdirSync as mkdirSync9 } from "fs";
+import { existsSync as existsSync25, readFileSync as readFileSync18, writeFileSync as writeFileSync7, unlinkSync as unlinkSync4, mkdirSync as mkdirSync9 } from "fs";
 import { dirname as dirname11, join as join23 } from "path";
 
 // src/hooks/ralph-loop/constants.ts
-var DEFAULT_STATE_FILE = ".sisyphus/ralph-loop.local.md";
+var DEFAULT_STATE_FILE = ".omo/ralph-loop.local.md";
 var DEFAULT_MAX_ITERATIONS = 100;
 var DEFAULT_COMPLETION_PROMISE = "DONE";
 
@@ -73784,7 +74194,7 @@ function getStateFilePath(directory, customPath) {
 }
 function readState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
-  if (!existsSync24(filePath)) {
+  if (!existsSync25(filePath)) {
     return null;
   }
   try {
@@ -73989,6 +74399,13 @@ var ERROR_GRACE_CYCLES = 3;
 var MIN_STABILIZATION_MS = 1000;
 var DEFAULT_EVENT_WATCHDOG_MS = 30000;
 var DEFAULT_SECONDARY_MEANINGFUL_WORK_TIMEOUT_MS = 60000;
+function isIncompleteTodo(value) {
+  if (!isRecord(value)) {
+    return true;
+  }
+  const status = value.status;
+  return status !== "completed" && status !== "cancelled";
+}
 async function pollForCompletion(ctx, eventState, abortController, options = {}) {
   const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
   const requiredConsecutive = options.requiredConsecutive ?? DEFAULT_REQUIRED_CONSECUTIVE;
@@ -74068,7 +74485,7 @@ Session ended with error: ${eventState.lastError}`));
         });
         const todos = normalizeSDKResponse(todosRes, []);
         const hasActiveChildren = Array.isArray(children) && children.length > 0;
-        const hasActiveTodos = Array.isArray(todos) && todos.some((t) => t?.status !== "completed" && t?.status !== "cancelled");
+        const hasActiveTodos = Array.isArray(todos) && todos.some(isIncompleteTodo);
         const hasActiveWork = hasActiveChildren || hasActiveTodos;
         if (hasActiveWork) {
           eventState.hasReceivedMeaningfulWork = true;
@@ -79328,7 +79745,7 @@ init_data_path();
 init_logger();
 init_plugin_identity();
 init_write_file_atomically();
-import { existsSync as existsSync25, mkdirSync as mkdirSync10, readFileSync as readFileSync19 } from "fs";
+import { existsSync as existsSync26, mkdirSync as mkdirSync10, readFileSync as readFileSync19 } from "fs";
 import { join as join24 } from "path";
 var POSTHOG_ACTIVITY_STATE_FILE = "posthog-activity.json";
 function getPostHogActivityStateFilePath() {
@@ -79342,7 +79759,7 @@ function isPostHogActivityState(value) {
 }
 function readPostHogActivityState() {
   const stateFilePath = getPostHogActivityStateFilePath();
-  if (!existsSync25(stateFilePath)) {
+  if (!existsSync26(stateFilePath)) {
     return {};
   }
   try {
@@ -79508,6 +79925,7 @@ function createCliPostHog() {
 }
 
 // src/cli/run/runner.ts
+init_prompt_async_gate();
 var EVENT_PROCESSOR_SHUTDOWN_TIMEOUT_MS = 2000;
 async function waitForEventProcessorShutdown(eventProcessor, timeoutMs = EVENT_PROCESSOR_SHUTDOWN_TIMEOUT_MS) {
   const completed = await Promise.race([
@@ -79576,18 +79994,31 @@ Interrupted. Shutting down...`));
       const eventState = createEventState();
       eventState.agentColorsByName = await loadAgentProfileColors(client3);
       const eventProcessor = processEvents(ctx, events.stream, eventState).catch(() => {});
-      await client3.session.promptAsync({
-        path: { id: sessionID },
-        body: {
-          agent: resolvedAgent,
-          ...resolvedModel ? { model: resolvedModel } : {},
-          tools: {
-            question: false
+      const promptResult = await dispatchInternalPrompt({
+        mode: "async",
+        client: client3,
+        sessionID,
+        source: "cli-run",
+        settleMs: 0,
+        input: {
+          path: { id: sessionID },
+          body: {
+            agent: resolvedAgent,
+            ...resolvedModel ? { model: resolvedModel } : {},
+            tools: {
+              question: false
+            },
+            parts: [{ type: "text", text: message }]
           },
-          parts: [{ type: "text", text: message }]
-        },
-        query: { directory }
+          query: { directory }
+        }
       });
+      if (promptResult.status === "failed") {
+        throw promptResult.error;
+      }
+      if (promptResult.status !== "dispatched") {
+        throw new Error(`Session ${sessionID} is not idle; promptAsync skipped by gate: ${promptResult.status}`);
+      }
       const exitCode = await pollForCompletion(ctx, eventState, abortController);
       abortController.abort();
       await waitForEventProcessorShutdown(eventProcessor);
@@ -79786,10 +80217,10 @@ async function getLocalVersion(options = {}) {
   }
 }
 // src/cli/doctor/checks/system.ts
-import { existsSync as existsSync36, readFileSync as readFileSync29 } from "fs";
+import { existsSync as existsSync37, readFileSync as readFileSync29 } from "fs";
 
 // src/cli/doctor/checks/system-binary.ts
-import { existsSync as existsSync33 } from "fs";
+import { existsSync as existsSync34 } from "fs";
 import { homedir as homedir8 } from "os";
 import { join as join31 } from "path";
 
@@ -79861,7 +80292,7 @@ function buildVersionCommand(binaryPath, platform) {
   }
   return [binaryPath, "--version"];
 }
-function findDesktopBinary(platform = process.platform, checkExists = existsSync33) {
+function findDesktopBinary(platform = process.platform, checkExists = existsSync34) {
   for (const desktopPath of getDesktopAppPaths(platform)) {
     if (checkExists(desktopPath)) {
       return { binary: "opencode", path: desktopPath };
@@ -79907,12 +80338,12 @@ function compareVersions3(current, minimum) {
 
 // src/cli/doctor/checks/system-plugin.ts
 init_shared();
-import { existsSync as existsSync34, readFileSync as readFileSync27 } from "fs";
+import { existsSync as existsSync35, readFileSync as readFileSync27 } from "fs";
 function detectConfigPath() {
   const paths = getOpenCodeConfigPaths({ binary: "opencode", version: null });
-  if (existsSync34(paths.configJsonc))
+  if (existsSync35(paths.configJsonc))
     return paths.configJsonc;
-  if (existsSync34(paths.configJson))
+  if (existsSync35(paths.configJson))
     return paths.configJson;
   return null;
 }
@@ -79996,7 +80427,7 @@ function getPluginInfo() {
 init_file_utils();
 init_checker();
 init_auto_update_checker();
-import { existsSync as existsSync35, readFileSync as readFileSync28 } from "fs";
+import { existsSync as existsSync36, readFileSync as readFileSync28 } from "fs";
 import { homedir as homedir9 } from "os";
 import { join as join32 } from "path";
 init_shared();
@@ -80013,17 +80444,17 @@ function resolveOpenCodeCacheDir() {
     return join32(xdgCacheHome, "opencode");
   const fromShared = getOpenCodeCacheDir();
   const platformDefault = join32(getPlatformDefaultCacheDir(), "opencode");
-  if (existsSync35(fromShared) || !existsSync35(platformDefault))
+  if (existsSync36(fromShared) || !existsSync36(platformDefault))
     return fromShared;
   return platformDefault;
 }
 function resolveExistingDir(dirPath) {
-  if (!existsSync35(dirPath))
+  if (!existsSync36(dirPath))
     return dirPath;
   return resolveSymlink(dirPath);
 }
 function readPackageJson(filePath) {
-  if (!existsSync35(filePath))
+  if (!existsSync36(filePath))
     return null;
   try {
     const content = readFileSync28(filePath, "utf-8");
@@ -80045,7 +80476,7 @@ function createPackageCandidates(rootDir) {
   }));
 }
 function selectInstalledPackage(candidate) {
-  return candidate.packageCandidates.find((packageCandidate) => existsSync35(packageCandidate.installedPackagePath)) ?? candidate.packageCandidates[0];
+  return candidate.packageCandidates.find((packageCandidate) => existsSync36(packageCandidate.installedPackagePath)) ?? candidate.packageCandidates[0];
 }
 function getExpectedVersion(cachePackage, packageName) {
   return normalizeVersion(cachePackage?.dependencies?.[packageName]) ?? normalizeVersion(cachePackage?.dependencies?.[PACKAGE_NAME]);
@@ -80066,7 +80497,7 @@ function getLoadedPluginVersion() {
       packageCandidates: createPackageCandidates(cacheDir)
     }
   ];
-  const selectedCandidate = candidates.find((candidate) => candidate.packageCandidates.some((packageCandidate) => existsSync35(packageCandidate.installedPackagePath))) ?? candidates[0];
+  const selectedCandidate = candidates.find((candidate) => candidate.packageCandidates.some((packageCandidate) => existsSync36(packageCandidate.installedPackagePath))) ?? candidates[0];
   const { cacheDir: selectedDir, cachePackagePath } = selectedCandidate;
   const selectedPackage = selectInstalledPackage(selectedCandidate);
   const installedPackagePath = selectedPackage.installedPackagePath;
@@ -80093,7 +80524,7 @@ function getSuggestedInstallTag(currentVersion) {
 // src/cli/doctor/checks/system.ts
 init_shared();
 init_plugin_identity();
-var defaultDeps4 = {
+var defaultDeps5 = {
   findOpenCodeBinary,
   getOpenCodeVersion: getOpenCodeVersion3,
   compareVersions: compareVersions3,
@@ -80105,7 +80536,7 @@ var defaultDeps4 = {
 function isConfigValid(configPath) {
   if (!configPath)
     return true;
-  if (!existsSync36(configPath))
+  if (!existsSync37(configPath))
     return false;
   try {
     parseJsonc(readFileSync29(configPath, "utf-8"));
@@ -80128,7 +80559,7 @@ function buildMessage(status, issues) {
     return `${issues.length} system issue(s) detected`;
   return `${issues.length} system warning(s) detected`;
 }
-async function gatherSystemInfo(deps = defaultDeps4) {
+async function gatherSystemInfo(deps = defaultDeps5) {
   const [binaryInfo, pluginInfo] = await Promise.all([
     deps.findOpenCodeBinary(),
     Promise.resolve(deps.getPluginInfo())
@@ -80147,7 +80578,7 @@ async function gatherSystemInfo(deps = defaultDeps4) {
     isLocalDev: pluginInfo.isLocalDev
   };
 }
-async function checkSystem(deps = defaultDeps4) {
+async function checkSystem(deps = defaultDeps5) {
   const [systemInfo, pluginInfo] = await Promise.all([
     gatherSystemInfo(deps),
     Promise.resolve(deps.getPluginInfo())
@@ -80236,7 +80667,7 @@ init_shared();
 
 // src/cli/doctor/checks/model-resolution-cache.ts
 init_shared();
-import { existsSync as existsSync37, readFileSync as readFileSync30 } from "fs";
+import { existsSync as existsSync38, readFileSync as readFileSync30 } from "fs";
 import { homedir as homedir10 } from "os";
 import { join as join33 } from "path";
 function getUserConfigDir2() {
@@ -80252,7 +80683,7 @@ function loadCustomProviderNames() {
     join33(configDir, "opencode.jsonc")
   ];
   for (const configPath of candidatePaths) {
-    if (!existsSync37(configPath))
+    if (!existsSync38(configPath))
       continue;
     try {
       const content = readFileSync30(configPath, "utf-8");
@@ -80267,7 +80698,7 @@ function loadCustomProviderNames() {
 function loadAvailableModelsFromCache() {
   const cacheFile = join33(getOpenCodeCacheDir(), "models.json");
   const customProviders = loadCustomProviderNames();
-  if (!existsSync37(cacheFile)) {
+  if (!existsSync38(cacheFile)) {
     if (customProviders.length > 0) {
       return { providers: customProviders, modelCount: 0, cacheExists: true };
     }
@@ -80642,7 +81073,7 @@ async function checkConfig() {
 }
 
 // src/cli/doctor/checks/dependencies.ts
-import { existsSync as existsSync38 } from "fs";
+import { existsSync as existsSync39 } from "fs";
 import { createRequire } from "module";
 import { dirname as dirname16, join as join38 } from "path";
 
@@ -80726,7 +81157,7 @@ async function checkAstGrepNapi() {
       path: null
     };
   } catch {
-    const { existsSync: existsSync39 } = await import("fs");
+    const { existsSync: existsSync40 } = await import("fs");
     const { join: join39 } = await import("path");
     const { homedir: homedir12 } = await import("os");
     const pathsToCheck = [
@@ -80734,7 +81165,7 @@ async function checkAstGrepNapi() {
       join39(process.cwd(), "node_modules", "@ast-grep", "napi")
     ];
     for (const napiPath of pathsToCheck) {
-      if (existsSync39(napiPath)) {
+      if (existsSync40(napiPath)) {
         return {
           name: "AST-Grep NAPI",
           required: false,
@@ -80760,7 +81191,7 @@ function findCommentCheckerPackageBinary() {
     const require2 = createRequire(import.meta.url);
     const pkgPath = require2.resolve("@code-yeongyu/comment-checker/package.json");
     const binaryPath = join38(dirname16(pkgPath), "bin", binaryName);
-    if (existsSync38(binaryPath))
+    if (existsSync39(binaryPath))
       return binaryPath;
   } catch {}
   return null;
@@ -80890,261 +81321,120 @@ async function getGhCliInfo() {
     error: authStatus.error
   };
 }
-// src/tools/lsp/server-definitions.ts
-var BUILTIN_SERVERS = {
-  typescript: { command: ["typescript-language-server", "--stdio"], extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"] },
-  deno: { command: ["deno", "lsp"], extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs"] },
-  vue: { command: ["vue-language-server", "--stdio"], extensions: [".vue"] },
-  eslint: { command: ["vscode-eslint-language-server", "--stdio"], extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts", ".vue"] },
-  oxlint: { command: ["oxlint", "--lsp"], extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts", ".vue", ".astro", ".svelte"] },
-  biome: { command: ["biome", "lsp-proxy", "--stdio"], extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts", ".json", ".jsonc", ".vue", ".astro", ".svelte", ".css", ".graphql", ".gql", ".html"] },
-  gopls: { command: ["gopls"], extensions: [".go"] },
-  "ruby-lsp": { command: ["rubocop", "--lsp"], extensions: [".rb", ".rake", ".gemspec", ".ru"] },
-  basedpyright: { command: ["basedpyright-langserver", "--stdio"], extensions: [".py", ".pyi"] },
-  pyright: { command: ["pyright-langserver", "--stdio"], extensions: [".py", ".pyi"] },
-  ty: { command: ["ty", "server"], extensions: [".py", ".pyi"] },
-  ruff: { command: ["ruff", "server"], extensions: [".py", ".pyi"] },
-  "elixir-ls": { command: ["elixir-ls"], extensions: [".ex", ".exs"] },
-  zls: { command: ["zls"], extensions: [".zig", ".zon"] },
-  csharp: { command: ["csharp-ls"], extensions: [".cs"] },
-  fsharp: { command: ["fsautocomplete"], extensions: [".fs", ".fsi", ".fsx", ".fsscript"] },
-  "sourcekit-lsp": { command: ["sourcekit-lsp"], extensions: [".swift", ".objc", ".objcpp"] },
-  rust: { command: ["rust-analyzer"], extensions: [".rs"] },
-  clangd: { command: ["clangd", "--background-index", "--clang-tidy"], extensions: [".c", ".cpp", ".cc", ".cxx", ".c++", ".h", ".hpp", ".hh", ".hxx", ".h++"] },
-  svelte: { command: ["svelteserver", "--stdio"], extensions: [".svelte"] },
-  astro: { command: ["astro-ls", "--stdio"], extensions: [".astro"] },
-  bash: { command: ["bash-language-server", "start"], extensions: [".sh", ".bash", ".zsh", ".ksh"] },
-  "bash-ls": { command: ["bash-language-server", "start"], extensions: [".sh", ".bash", ".zsh", ".ksh"] },
-  jdtls: { command: ["jdtls"], extensions: [".java"] },
-  "yaml-ls": { command: ["yaml-language-server", "--stdio"], extensions: [".yaml", ".yml"] },
-  "lua-ls": { command: ["lua-language-server"], extensions: [".lua"] },
-  php: { command: ["intelephense", "--stdio"], extensions: [".php"] },
-  dart: { command: ["dart", "language-server", "--lsp"], extensions: [".dart"] },
-  terraform: { command: ["terraform-ls", "serve"], extensions: [".tf", ".tfvars"] },
-  "terraform-ls": { command: ["terraform-ls", "serve"], extensions: [".tf", ".tfvars"] },
-  prisma: { command: ["prisma", "language-server"], extensions: [".prisma"] },
-  "ocaml-lsp": { command: ["ocamllsp"], extensions: [".ml", ".mli"] },
-  texlab: { command: ["texlab"], extensions: [".tex", ".bib"] },
-  dockerfile: { command: ["docker-langserver", "--stdio"], extensions: [".dockerfile"] },
-  gleam: { command: ["gleam", "lsp"], extensions: [".gleam"] },
-  "clojure-lsp": { command: ["clojure-lsp", "listen"], extensions: [".clj", ".cljs", ".cljc", ".edn"] },
-  nixd: { command: ["nixd"], extensions: [".nix"] },
-  tinymist: { command: ["tinymist"], extensions: [".typ", ".typc"] },
-  "haskell-language-server": { command: ["haskell-language-server-wrapper", "--lsp"], extensions: [".hs", ".lhs"] },
-  "kotlin-ls": { command: ["kotlin-lsp"], extensions: [".kt", ".kts"] }
-};
-// src/tools/lsp/server-config-loader.ts
-import { existsSync as existsSync39, readFileSync as readFileSync33 } from "fs";
+
+// src/cli/doctor/checks/tools-lsp.ts
+import { readFileSync as readFileSync33 } from "fs";
 import { join as join39 } from "path";
-init_shared();
-init_jsonc_parser();
-function loadJsonFile(path13) {
-  if (!existsSync39(path13))
-    return null;
+
+// src/mcp/lsp.ts
+import { existsSync as existsSync40 } from "fs";
+import { dirname as dirname17, resolve as resolve6 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var SUBMODULE_REL = "packages/lsp-tools-mcp";
+var DIST_CLI_REL = "dist/cli.js";
+var SOURCE_CLI_REL = "src/cli.ts";
+var PROJECT_LSP_CONFIG = ".opencode/lsp.json";
+function addAncestorCommandCandidates(startDirectory, target, seenPaths, pathExists) {
+  let currentDirectory = resolve6(startDirectory);
+  while (true) {
+    const distCliPath = resolve6(currentDirectory, SUBMODULE_REL, DIST_CLI_REL);
+    if (!seenPaths.has(distCliPath)) {
+      seenPaths.add(distCliPath);
+      target.push({ command: ["node", distCliPath, "mcp"], path: distCliPath, exists: pathExists(distCliPath) });
+    }
+    const sourceCliPath = resolve6(currentDirectory, SUBMODULE_REL, SOURCE_CLI_REL);
+    if (!seenPaths.has(sourceCliPath)) {
+      seenPaths.add(sourceCliPath);
+      target.push({ command: ["bun", sourceCliPath, "mcp"], path: sourceCliPath, exists: pathExists(sourceCliPath) });
+    }
+    const parentDirectory = resolve6(currentDirectory, "..");
+    if (parentDirectory === currentDirectory) {
+      return;
+    }
+    currentDirectory = parentDirectory;
+  }
+}
+function getModuleDirectory(moduleUrl) {
   try {
-    return parseJsonc(readFileSync33(path13, "utf-8"));
+    return dirname17(fileURLToPath3(moduleUrl));
   } catch {
     return null;
   }
 }
-function getConfigPaths2() {
-  const cwd = process.cwd();
-  const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  return {
-    project: detectPluginConfigFile(join39(cwd, ".opencode")).path,
-    user: detectPluginConfigFile(configDir).path,
-    opencode: detectConfigFile(join39(configDir, "opencode")).path
-  };
-}
-function loadAllConfigs() {
-  const paths = getConfigPaths2();
-  const configs = new Map;
-  const project = loadJsonFile(paths.project);
-  if (project)
-    configs.set("project", project);
-  const user = loadJsonFile(paths.user);
-  if (user)
-    configs.set("user", user);
-  const opencode = loadJsonFile(paths.opencode);
-  if (opencode)
-    configs.set("opencode", opencode);
-  return configs;
-}
-function getMergedServers() {
-  const configs = loadAllConfigs();
-  const servers = [];
-  const disabled = new Set;
-  const seen = new Set;
-  const sources = ["project", "user", "opencode"];
-  for (const source of sources) {
-    const config2 = configs.get(source);
-    if (!config2?.lsp)
-      continue;
-    for (const [id, entry] of Object.entries(config2.lsp)) {
-      if (entry.disabled) {
-        disabled.add(id);
-        continue;
-      }
-      if (seen.has(id))
-        continue;
-      if (!entry.command || !entry.extensions)
-        continue;
-      servers.push({
-        id,
-        command: entry.command,
-        extensions: entry.extensions,
-        priority: entry.priority ?? 0,
-        env: entry.env,
-        initialization: entry.initialization,
-        source
-      });
-      seen.add(id);
-    }
+function resolveLspCommand(options = {}) {
+  const pathExists = options.exists ?? existsSync40;
+  const candidates = [];
+  const seenPaths = new Set;
+  const moduleDirectory = getModuleDirectory(options.moduleUrl ?? import.meta.url);
+  if (moduleDirectory) {
+    addAncestorCommandCandidates(moduleDirectory, candidates, seenPaths, pathExists);
   }
-  for (const [id, config2] of Object.entries(BUILTIN_SERVERS)) {
-    if (disabled.has(id) || seen.has(id))
-      continue;
-    servers.push({
-      id,
-      command: config2.command,
-      extensions: config2.extensions,
-      priority: -100,
-      source: "opencode"
-    });
+  addAncestorCommandCandidates(options.cwd ?? process.cwd(), candidates, seenPaths, pathExists);
+  const distCandidate = candidates.find((candidate) => candidate.path.endsWith(DIST_CLI_REL) && candidate.exists);
+  if (distCandidate) {
+    return distCandidate.command;
   }
-  return servers.sort((a, b3) => {
-    if (a.source !== b3.source) {
-      const order = { project: 0, user: 1, opencode: 2 };
-      return order[a.source] - order[b3.source];
+  const sourceCandidate = candidates.find((candidate) => candidate.path.endsWith(SOURCE_CLI_REL) && candidate.exists);
+  if (sourceCandidate) {
+    return sourceCandidate.command;
+  }
+  return candidates[0]?.command ?? ["node", resolve6(process.cwd(), SUBMODULE_REL, DIST_CLI_REL), "mcp"];
+}
+function createLspMcpConfig(options = {}) {
+  return {
+    type: "local",
+    command: resolveLspCommand(options),
+    enabled: true,
+    environment: {
+      LSP_TOOLS_MCP_PROJECT_CONFIG: PROJECT_LSP_CONFIG
     }
-    return b3.priority - a.priority;
-  });
+  };
 }
 
-// src/tools/lsp/server-installation.ts
-import { existsSync as existsSync40 } from "fs";
-import { delimiter as delimiter2, join as join41 } from "path";
-
-// src/tools/lsp/server-path-bases.ts
+// src/cli/doctor/checks/tools-lsp.ts
 init_shared();
-import { join as join40 } from "path";
-function getLspServerAdditionalPathBases(workingDirectory) {
-  const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const dataDir = join40(getDataDir(), "opencode");
-  return [
-    join40(workingDirectory, "node_modules", ".bin"),
-    join40(configDir, "bin"),
-    join40(configDir, "node_modules", ".bin"),
-    join40(dataDir, "bin"),
-    join40(dataDir, "bin", "node_modules", ".bin")
-  ];
-}
-
-// src/tools/lsp/server-installation.ts
-function isServerInstalled(command) {
-  if (command.length === 0)
-    return false;
-  const cmd = command[0];
-  if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync40(cmd))
-      return true;
-  }
-  const isWindows = process.platform === "win32";
-  let exts = [""];
-  if (isWindows) {
-    const pathExt = process.env.PATHEXT || "";
-    if (pathExt) {
-      const systemExts = pathExt.split(";").filter(Boolean);
-      exts = [...new Set([...exts, ...systemExts, ".exe", ".cmd", ".bat", ".ps1"])];
-    } else {
-      exts = ["", ".exe", ".cmd", ".bat", ".ps1"];
-    }
-  }
-  let pathEnv = process.env.PATH || "";
-  if (isWindows && !pathEnv) {
-    pathEnv = process.env.Path || "";
-  }
-  const paths = pathEnv.split(delimiter2);
-  for (const p2 of paths) {
-    for (const suffix of exts) {
-      if (existsSync40(join41(p2, cmd + suffix))) {
-        return true;
-      }
-    }
-  }
-  for (const base of getLspServerAdditionalPathBases(process.cwd())) {
-    for (const suffix of exts) {
-      if (existsSync40(join41(base, cmd + suffix))) {
-        return true;
-      }
-    }
+var PROJECT_CONFIG_DIR3 = join39(process.cwd(), ".opencode");
+function readOmoConfig(configDirectory) {
+  const detected = detectPluginConfigFile(configDirectory);
+  if (detected.format === "none") {
+    return null;
   }
-  if (cmd === "bun" || cmd === "node") {
-    return true;
+  try {
+    const content = readFileSync33(detected.path, "utf-8");
+    return parseJsonc(content);
+  } catch {
+    return null;
   }
-  return false;
 }
-
-// src/tools/lsp/server-resolution.ts
-function getAllServers() {
-  const configs = loadAllConfigs();
-  const servers = getMergedServers();
-  const disabled = new Set;
-  for (const config2 of configs.values()) {
-    if (!config2.lsp)
-      continue;
-    for (const [id, entry] of Object.entries(config2.lsp)) {
-      if (entry.disabled)
-        disabled.add(id);
-    }
-  }
-  const result = [];
-  const seen = new Set;
-  for (const server2 of servers) {
-    if (seen.has(server2.id))
-      continue;
-    result.push({
-      id: server2.id,
-      installed: isServerInstalled(server2.command),
-      extensions: server2.extensions,
-      disabled: false,
-      source: server2.source,
-      priority: server2.priority
-    });
-    seen.add(server2.id);
-  }
-  for (const id of disabled) {
-    if (seen.has(id))
-      continue;
-    const builtin = BUILTIN_SERVERS[id];
-    result.push({
-      id,
-      installed: builtin ? isServerInstalled(builtin.command) : false,
-      extensions: builtin?.extensions || [],
-      disabled: true,
-      source: "disabled",
-      priority: 0
-    });
-  }
-  return result;
+function isLspMcpDisabled() {
+  const userConfigDirectory = getOpenCodeConfigDir({ binary: "opencode" });
+  const userConfig = readOmoConfig(userConfigDirectory);
+  const projectConfig = readOmoConfig(PROJECT_CONFIG_DIR3);
+  const disabledMcps = new Set([
+    ...userConfig?.disabled_mcps ?? [],
+    ...projectConfig?.disabled_mcps ?? []
+  ]);
+  return disabledMcps.has("lsp");
 }
-// src/cli/doctor/checks/tools-lsp.ts
 function getInstalledLspServers() {
-  const servers = getAllServers();
-  return servers.filter((s) => s.installed && !s.disabled).map((s) => ({ id: s.id, extensions: s.extensions }));
+  if (isLspMcpDisabled()) {
+    return [];
+  }
+  const lspMcpConfig = createLspMcpConfig();
+  return lspMcpConfig.enabled ? [{ id: "lsp-tools-mcp", extensions: ["*"] }] : [];
 }
 
 // src/cli/doctor/checks/tools-mcp.ts
 init_shared();
 import { existsSync as existsSync41, readFileSync as readFileSync34 } from "fs";
 import { homedir as homedir12 } from "os";
-import { join as join42 } from "path";
+import { join as join40 } from "path";
 var BUILTIN_MCP_SERVERS = ["context7", "grep_app"];
 function getMcpConfigPaths() {
   return [
-    join42(homedir12(), ".claude", ".mcp.json"),
-    join42(process.cwd(), ".mcp.json"),
-    join42(process.cwd(), ".claude", ".mcp.json")
+    join40(homedir12(), ".claude", ".mcp.json"),
+    join40(process.cwd(), ".mcp.json"),
+    join40(process.cwd(), ".claude", ".mcp.json")
   ];
 }
 function loadUserMcpConfig() {
@@ -81749,11 +82039,11 @@ async function refreshModelCapabilities(options, deps = {}) {
 
 // src/features/mcp-oauth/storage.ts
 init_shared();
-import { chmodSync as chmodSync2, existsSync as existsSync42, mkdirSync as mkdirSync12, readFileSync as readFileSync36, renameSync as renameSync4, unlinkSync as unlinkSync6, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname17, join as join43 } from "path";
+import { chmodSync as chmodSync2, existsSync as existsSync42, mkdirSync as mkdirSync12, readFileSync as readFileSync36, renameSync as renameSync5, unlinkSync as unlinkSync7, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname18, join as join41 } from "path";
 var STORAGE_FILE_NAME = "mcp-oauth.json";
 function getMcpOauthStoragePath() {
-  return join43(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
+  return join41(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME);
 }
 function normalizeHost2(serverHost) {
   let host = serverHost.trim();
@@ -81803,14 +82093,14 @@ function readStore() {
 function writeStore(store2) {
   const filePath = getMcpOauthStoragePath();
   try {
-    const dir = dirname17(filePath);
+    const dir = dirname18(filePath);
     if (!existsSync42(dir)) {
       mkdirSync12(dir, { recursive: true });
     }
     const tempPath = `${filePath}.tmp.${Date.now()}`;
     writeFileSync10(tempPath, JSON.stringify(store2, null, 2), { encoding: "utf-8", mode: 384 });
     chmodSync2(tempPath, 384);
-    renameSync4(tempPath, filePath);
+    renameSync5(tempPath, filePath);
     return true;
   } catch {
     return false;
@@ -81842,7 +82132,7 @@ function deleteToken(serverHost, resource) {
     try {
       const filePath = getMcpOauthStoragePath();
       if (existsSync42(filePath)) {
-        unlinkSync6(filePath);
+        unlinkSync7(filePath);
       }
       return true;
     } catch {
@@ -82010,7 +82300,7 @@ async function getOrRegisterClient(options) {
   }
 }
 function parseRegistrationResponse(data) {
-  if (!isRecord8(data))
+  if (!isRecord10(data))
     return null;
   const clientId = data.client_id;
   if (typeof clientId !== "string" || clientId.length === 0)
@@ -82021,7 +82311,7 @@ function parseRegistrationResponse(data) {
   }
   return { clientId };
 }
-function isRecord8(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null;
 }
 
@@ -82061,7 +82351,7 @@ function buildAuthorizationUrl(authorizationEndpoint, options) {
 }
 var CALLBACK_TIMEOUT_MS = 5 * 60 * 1000;
 function startCallbackServer(port) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     let timeoutId;
     const server2 = createServer2((request, response) => {
       clearTimeout(timeoutId);
@@ -82087,7 +82377,7 @@ function startCallbackServer(port) {
       response.writeHead(200, { "content-type": "text/html" });
       response.end("<html><body><h1>Authorization successful. You can close this tab.</h1></body></html>");
       server2.close();
-      resolve6({ code, state: state2 });
+      resolve7({ code, state: state2 });
     });
     timeoutId = setTimeout(() => {
       server2.close();