oh-my-opencode 5.0.0-beta.30 → 5.0.0-beta.32

package/packages/omo-codex/plugin/components/codegraph/src/mcp-unavailable.ts

@@ -7,6 +7,7 @@ import {
 	runJsonRpcStdioServer,
 	successResponse,
 	type JsonRpcResponse,
+	type McpLifecycleLog,
 	type ParentWatchdogConfig,
 } from "../../../../../mcp-stdio-core/src/index.ts";
 
@@ -18,6 +19,9 @@ export interface UnavailableCodegraphMcpOptions {
 	// Test seam: production callers leave this unset so the watchdog uses its
 	// defaults (parentPid = process.ppid, 30s poll).
 	readonly parentWatchdog?: ParentWatchdogConfig;
+	// Test seam: surfaces the mcp-stdio-core lifecycle log so tests can pin the
+	// resolved idle timeout without waiting a real timeout out.
+	readonly lifecycleLog?: McpLifecycleLog;
 }
 
 interface UnavailableCodegraphMcpHandlerOptions {
@@ -36,7 +40,15 @@ export async function runUnavailableCodegraphMcpServer(
 		},
 		input: options.input,
 		output: options.output,
+		// Idle stays disabled: the codex host never respawns an exited stdio
+		// MCP server (codex-rs auto-reconnects only its own codex_apps server),
+		// and since #6548 the default idle timer actually destroys stdin — so an
+		// inherited 10-minute default would silently kill this stub mid-session
+		// and turn later codegraph tool calls into dead-connection errors.
+		idleTimeoutMs: 0,
 		parentWatchdog: options.parentWatchdog ?? {},
+		// Conditional spread keeps this assignable under exactOptionalPropertyTypes.
+		...(options.lifecycleLog === undefined ? {} : { log: options.lifecycleLog }),
 	});
 }
 

package/packages/omo-codex/plugin/components/codegraph/test/serve-unavailable-idle.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from "bun:test";
+import { PassThrough } from "node:stream";
+
+import { runUnavailableCodegraphMcpServer } from "../src/mcp-unavailable.ts";
+
+describe("unavailable codegraph MCP idle teardown", () => {
+	it("#given the codex host (no respawn for exited stdio servers) #when the unavailable stub starts #then the idle timeout is disabled", async () => {
+		// given — codex never respawns a user-configured stdio MCP server
+		// (codex-rs reconnects only its own codex_apps server), so if the stub
+		// inherited the mcp-stdio-core default idle timeout it would destroy its
+		// own stdin after 10 idle minutes and every later codegraph tool call in
+		// a long-lived session would fail on a dead connection instead of
+		// answering with the skip reason.
+		const stdin = new PassThrough();
+		const stdout = new PassThrough();
+		stdout.resume();
+		const lifecycle: Array<{ readonly event: string; readonly data?: unknown }> = [];
+
+		try {
+			// when
+			const served = runUnavailableCodegraphMcpServer({
+				input: stdin,
+				output: stdout,
+				reason: "CodeGraph MCP skipped: test reason",
+				serverVersion: "0.0.0-test",
+				lifecycleLog: (event, data) => {
+					lifecycle.push({ event, data });
+				},
+			});
+			const outcome = await Promise.race([
+				served.then(() => "settled" as const),
+				Bun.sleep(500).then(() => "parked" as const),
+			]);
+
+			// then — the server must park on the held-open pipe (no idle timer
+			// tore it down) and must have started with the timeout disabled.
+			expect(outcome).toBe("parked");
+			expect(lifecycle).toContainEqual({
+				event: "stdio_started",
+				data: expect.objectContaining({ idle_timeout_ms: 0 }),
+			});
+		} finally {
+			stdin.destroy();
+			stdout.destroy();
+		}
+	});
+});

package/packages/omo-codex/plugin/components/comment-checker/hooks/hooks.json

@@ -8,7 +8,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-tool-use",
 						"timeout": 30,
-						"statusMessage": "(OmO 5.0.0-beta.30) Checking Comments"
+						"statusMessage": "(OmO 5.0.0-beta.32) Checking Comments"
 					}
 				]
 			}

package/packages/omo-codex/plugin/components/comment-checker/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-comment-checker",
-	"version": "5.0.0-beta.30",
+	"version": "5.0.0-beta.32",
 	"description": "Codex plugin that runs comment-checker after edit-like PostToolUse hooks.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",

package/packages/omo-codex/plugin/components/git-bash/hooks/hooks.json

@@ -8,7 +8,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook pre-tool-use",
 						"timeout": 5,
-						"statusMessage": "(OmO 5.0.0-beta.30) Recommending Git Bash MCP"
+						"statusMessage": "(OmO 5.0.0-beta.32) Recommending Git Bash MCP"
 					}
 				]
 			}
@@ -20,7 +20,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-compact",
 						"timeout": 5,
-						"statusMessage": "(OmO 5.0.0-beta.30) Resetting Git Bash MCP Reminder"
+						"statusMessage": "(OmO 5.0.0-beta.32) Resetting Git Bash MCP Reminder"
 					}
 				]
 			}

package/packages/omo-codex/plugin/components/git-bash/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sisyphuslabs/codex-git-bash-hook",
-	"version": "5.0.0-beta.30",
+	"version": "5.0.0-beta.32",
 	"description": "Codex hook component that reminds Windows sessions to prefer the OMO git_bash MCP.",
 	"type": "module",
 	"private": true,

package/packages/omo-codex/plugin/components/lazycodex-executor-verify/hooks/hooks.json

@@ -8,7 +8,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/lazycodex-executor-verify/dist/cli.js\" hook subagent-stop",
 						"timeout": 10,
-						"statusMessage": "(OmO 5.0.0-beta.30) Verifying LazyCodex Executor Evidence"
+						"statusMessage": "(OmO 5.0.0-beta.32) Verifying LazyCodex Executor Evidence"
 					}
 				]
 			}

package/packages/omo-codex/plugin/components/lazycodex-executor-verify/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-lazycodex-executor-verify",
-	"version": "5.0.0-beta.30",
+	"version": "5.0.0-beta.32",
 	"description": "Codex SubagentStop evidence verifier for LazyCodex executor completions.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",

package/packages/omo-codex/plugin/components/lsp/dist/.omo-runtime-manifest.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
-  "version": "5.0.0-beta.30",
-  "inputDigest": "sha256:e51c462bed771b67810446ab27ee35a6009800cb9e3869f41234c80ca6818caa",
+  "version": "5.0.0-beta.32",
+  "inputDigest": "sha256:7ebeb55787bcfcf32f5cdd2782c145f22c9aa8c595b7dedde0228036267ccfee",
   "outputs": [
     {
       "path": "cli.d.ts",
@@ -9,7 +9,7 @@
     },
     {
       "path": "cli.js",
-      "sha256": "5e3645a0299f523876c758e645e70f7a122a46da6ec7d3994473ec19f9048430"
+      "sha256": "89f0a2360dc1977cc00f2cdb661ff6929a7b90131728488502834a372840db3c"
     },
     {
       "path": "codex-hook-cli.d.ts",

package/packages/omo-codex/plugin/components/lsp/dist/cli.js

@@ -745,6 +745,16 @@ class LspProcessSpawnError extends Error {
     this.name = "LspProcessSpawnError";
   }
 }
+
+class LspClientRespawnBudgetExceededError extends Error {
+  constructor(serverId, root, retryLimit) {
+    super(`LSP server ${serverId} at ${root} failed to stay alive; respawn budget exhausted ` + `(${retryLimit} consecutive dead generations). Retrying after the cooldown may succeed.`);
+    this.serverId = serverId;
+    this.root = root;
+    this.retryLimit = retryLimit;
+    this.name = "LspClientRespawnBudgetExceededError";
+  }
+}
 function isLspDeadConnectionError(err) {
   return err instanceof LspConnectionClosedError || err instanceof LspProcessExitedError;
 }
@@ -756,6 +766,11 @@ function reportBestEffortCleanupError(operation, error, logger = writeCleanupErr
   const message = error instanceof Error ? error.message : String(error);
   logger(`[lsp] ignored ${operation} failure during cleanup: ${message}`);
 }
+var realTimerProvider = {
+  now: () => Date.now(),
+  setTimeout: (callback, delayMs) => setTimeout(callback, delayMs),
+  clearTimeout: (handle) => clearTimeout(handle)
+};
 var DEFAULT_MAX_REFERENCES = 200;
 var DEFAULT_MAX_SYMBOLS = 200;
 var DEFAULT_MAX_DIAGNOSTICS = 200;
@@ -767,6 +782,8 @@ var MAX_RESIDENT_CLIENTS = 6;
 var REAPER_INTERVAL_MS = 60000;
 var STOP_HARD_KILL_TIMEOUT_MS = 5000;
 var STOP_SIGKILL_GRACE_MS = 1000;
+var CLIENT_RESPAWN_RETRY_LIMIT = 2;
+var CLIENT_RESPAWN_COOLDOWN_MS = 60000;
 var HEADER_SEPARATOR2 = `\r
 \r
 `;
@@ -1282,6 +1299,7 @@ class LspClientTransport {
     this.documentFormattingSupported = false;
     this.requestTimeoutMs = timeouts.requestTimeoutMs ?? REQUEST_TIMEOUT_MS;
     this.initializeTimeoutMs = timeouts.initializeTimeoutMs ?? INIT_TIMEOUT_MS;
+    this.timerProvider = timeouts.timerProvider ?? realTimerProvider;
   }
   pid() {
     return this.proc?.pid;
@@ -1382,7 +1400,7 @@ class LspClientTransport {
     const options = args[1];
     const timeoutMs = options?.timeoutMs ?? this.requestTimeoutMs;
     const timeoutController = new AbortController;
-    const timeoutHandle = setTimeout(() => {
+    const timeoutHandle = this.timerProvider.setTimeout(() => {
       const stderrTail = this.stderrBuffer.slice(-5).join(`
 `);
       timeoutController.abort(new LspRequestTimeoutError(method, stderrTail || undefined));
@@ -1401,7 +1419,7 @@ class LspClientTransport {
       }
       throw error;
     } finally {
-      clearTimeout(timeoutHandle);
+      this.timerProvider.clearTimeout(timeoutHandle);
       combinedSignal.dispose();
     }
   }
@@ -1771,6 +1789,17 @@ function canonicalPath(filePath) {
     return absolute;
   }
 }
+function normalizeDocumentUri(uri) {
+  let decoded = uri;
+  try {
+    decoded = decodeURIComponent(uri);
+  } catch {
+    decoded = uri;
+  }
+  if (process.platform !== "win32")
+    return decoded;
+  return decoded.replace(/^(file:\/\/\/)([a-z]):/, (_match, prefix, drive) => `${prefix}${drive.toUpperCase()}:`);
+}
 function isSameOrDescendant(candidate, parent) {
   const suffix = relative2(parent, candidate);
   return suffix === "" || !suffix.startsWith("..") && suffix !== "..";
@@ -1787,7 +1816,12 @@ class WorkspaceDocumentState {
     this.openDocuments = new Map;
     this.openByUri = new Map;
     this.openPromises = new Map;
-    this.now = options.now ?? (() => Date.now());
+    this.timerProvider = options.timerProvider ?? {
+      now: options.now ?? (() => Date.now()),
+      setTimeout: (callback, delayMs) => setTimeout(callback, delayMs),
+      clearTimeout: (handle) => clearTimeout(handle)
+    };
+    this.now = () => this.timerProvider.now();
     this.versionlessPublishQuiescenceMs = options.versionlessPublishQuiescenceMs ?? DEFAULT_VERSIONLESS_PUBLISH_QUIESCENCE_MS;
   }
   async openFile(filePath) {
@@ -1809,7 +1843,7 @@ class WorkspaceDocumentState {
     return this.openDocuments.get(canonicalPath(filePath))?.version;
   }
   getStoredDiagnostics(uri) {
-    const state = this.openByUri.get(uri);
+    const state = this.openByUri.get(normalizeDocumentUri(uri));
     if (!state)
       return [];
     return state.lastPublish?.diagnostics ?? state.pullCache?.diagnostics ?? [];
@@ -1831,13 +1865,13 @@ class WorkspaceDocumentState {
     return state !== undefined && state.uri === snapshot.uri && state.version === snapshot.version && state.generation === snapshot.documentGeneration;
   }
   getPullCache(snapshot) {
-    const state = this.openByUri.get(snapshot.uri);
+    const state = this.openByUri.get(normalizeDocumentUri(snapshot.uri));
     if (!state?.pullCache || state.pullCache.documentVersion !== snapshot.version)
       return null;
     return state.pullCache;
   }
   recordPullDiagnostics(snapshot, report) {
-    const state = this.openByUri.get(snapshot.uri);
+    const state = this.openByUri.get(normalizeDocumentUri(snapshot.uri));
     if (!state)
       return;
     state.pullCache = {
@@ -1847,7 +1881,7 @@ class WorkspaceDocumentState {
     };
   }
   recordPublishedDiagnostics(params) {
-    const state = this.openByUri.get(params.uri);
+    const state = this.openByUri.get(normalizeDocumentUri(params.uri));
     if (!state)
       return;
     state.publishGeneration += 1;
@@ -1861,7 +1895,7 @@ class WorkspaceDocumentState {
     this.notifyWaiters(state);
   }
   resolvePushDiagnostics(snapshot) {
-    const state = this.openByUri.get(snapshot.uri);
+    const state = this.openByUri.get(normalizeDocumentUri(snapshot.uri));
     if (!state?.lastPublish)
       return { status: "missing" };
     const publish = state.lastPublish;
@@ -1875,7 +1909,7 @@ class WorkspaceDocumentState {
     return waitMs === 0 ? { status: "ready", diagnostics: publish.diagnostics } : { status: "wait", waitMs };
   }
   waitForDiagnosticsActivity(snapshot, timeoutMs) {
-    const state = this.openByUri.get(snapshot.uri);
+    const state = this.openByUri.get(normalizeDocumentUri(snapshot.uri));
     if (!state || timeoutMs <= 0)
       return Promise.resolve();
     return new Promise((resolveActivity) => {
@@ -1884,11 +1918,11 @@ class WorkspaceDocumentState {
         if (settled)
           return;
         settled = true;
-        clearTimeout(timer);
+        this.timerProvider.clearTimeout(timer);
         state.waiters.delete(finish);
         resolveActivity();
       };
-      const timer = setTimeout(finish, timeoutMs);
+      const timer = this.timerProvider.setTimeout(finish, timeoutMs);
       if (typeof timer.unref === "function")
         timer.unref();
       state.waiters.add(finish);
@@ -1996,7 +2030,7 @@ class WorkspaceDocumentState {
         waiters: new Set
       };
       this.openDocuments.set(path2, state);
-      this.openByUri.set(state.uri, state);
+      this.openByUri.set(normalizeDocumentUri(state.uri), state);
       this.notifyWaiters(state);
       await this.sendNotification("textDocument/didOpen", {
         textDocument: { uri: state.uri, languageId: state.languageId, version: state.version, text }
@@ -2021,7 +2055,7 @@ class WorkspaceDocumentState {
   }
   async closeDocument(state) {
     this.openDocuments.delete(state.path);
-    this.openByUri.delete(state.uri);
+    this.openByUri.delete(normalizeDocumentUri(state.uri));
     this.clearDiagnostics(state.uri);
     this.notifyWaiters(state);
     await this.sendNotification("textDocument/didClose", { textDocument: { uri: state.uri } });
@@ -3071,6 +3105,7 @@ class LspClient extends LspClientConnection {
     this.diagnosticPullErrors = [];
     this.diagnosticsFreshnessTimeoutMs = options.diagnosticsFreshnessTimeoutMs ?? DIAGNOSTICS_FRESHNESS_TIMEOUT_MS;
     this.documents = new WorkspaceDocumentState((method, params) => this.sendNotification(method, params), (uri) => this.diagnosticsStore.delete(uri), {
+      timerProvider: this.timerProvider,
       versionlessPublishQuiescenceMs: options.versionlessPublishQuiescenceMs ?? VERSIONLESS_PUBLISH_QUIESCENCE_MS
     });
     this.workspaceMutations = new WorkspaceMutationController(root, this.documents);
@@ -3174,7 +3209,7 @@ class LspClient extends LspClientConnection {
     const absPath = this.resolveWorkspacePath(filePath);
     const uri = pathToFileURL3(absPath).href;
     await this.openFile(absPath);
-    const deadlineAt = Date.now() + this.diagnosticsFreshnessTimeoutMs;
+    const deadlineAt = this.timerProvider.now() + this.diagnosticsFreshnessTimeoutMs;
     for (;; ) {
       signal?.throwIfAborted();
       const snapshot = this.documents.captureDiagnosticSnapshot(absPath);
@@ -3187,7 +3222,7 @@ class LspClient extends LspClientConnection {
       if (!pushFallbackOnly) {
         const cached = this.documents.getPullCache(snapshot);
         try {
-          const remainingMs2 = deadlineAt - Date.now();
+          const remainingMs2 = deadlineAt - this.timerProvider.now();
           if (remainingMs2 <= 0)
             return this.freshnessTimeout(absPath);
           const result = await this.sendRequest("textDocument/diagnostic", {
@@ -3222,7 +3257,7 @@ class LspClient extends LspClientConnection {
       }
       if (!pushFallbackOnly)
         continue;
-      const remainingMs = deadlineAt - Date.now();
+      const remainingMs = deadlineAt - this.timerProvider.now();
       if (remainingMs <= 0) {
         if (!this.isDiagnosticPullSupported() && snapshot.publishGeneration === 0) {
           const cached = this.documents.getPullCache(snapshot);
@@ -3378,6 +3413,8 @@ function awaitWithSignal2(promise, signal) {
 class LspManager {
   constructor(options = {}) {
     this.clients = new Map;
+    this.pendingStops = new Map;
+    this.respawnBudgets = new Map;
     this.reaperHandle = null;
     this.signalDisposer = null;
     this.disposed = false;
@@ -3403,17 +3440,52 @@ class LspManager {
   getKey(root, serverId) {
     return `${root}::${serverId}`;
   }
+  tombstoneStop(key, client) {
+    const stop = stopClientBestEffort(client);
+    this.pendingStops.set(key, stop);
+    stop.finally(() => {
+      if (this.pendingStops.get(key) === stop) {
+        this.pendingStops.delete(key);
+      }
+    });
+    return stop;
+  }
+  recordDeadGeneration(key) {
+    let budget = this.respawnBudgets.get(key);
+    if (budget === undefined) {
+      budget = { deadGenerations: 0, exhaustedAt: null };
+      this.respawnBudgets.set(key, budget);
+    }
+    budget.deadGenerations += 1;
+  }
+  markHealthyGeneration(key) {
+    this.respawnBudgets.delete(key);
+  }
+  ensureRespawnAllowed(key, root, serverId) {
+    const budget = this.respawnBudgets.get(key);
+    if (budget === undefined || budget.deadGenerations < CLIENT_RESPAWN_RETRY_LIMIT)
+      return;
+    if (budget.exhaustedAt === null) {
+      budget.exhaustedAt = this.now();
+      throw new LspClientRespawnBudgetExceededError(serverId, root, CLIENT_RESPAWN_RETRY_LIMIT);
+    }
+    if (this.now() - budget.exhaustedAt < CLIENT_RESPAWN_COOLDOWN_MS) {
+      throw new LspClientRespawnBudgetExceededError(serverId, root, CLIENT_RESPAWN_RETRY_LIMIT);
+    }
+    budget.deadGenerations = 0;
+    budget.exhaustedAt = null;
+  }
   reapStale() {
     const t = this.now();
     for (const [key, managed] of this.clients) {
       if (managed.isInitializing && managed.initializingSince !== null && t - managed.initializingSince > this.initTimeoutMs) {
-        stopClientBestEffort(managed.client);
         this.clients.delete(key);
+        this.tombstoneStop(key, managed.client);
         continue;
       }
       if (!managed.isInitializing && managed.refCount === 0 && managed.pendingWaiters === 0 && t - managed.lastUsedAt > this.idleTimeoutMs) {
-        stopClientBestEffort(managed.client);
         this.clients.delete(key);
+        this.tombstoneStop(key, managed.client);
       }
     }
   }
@@ -3423,7 +3495,7 @@ class LspManager {
       if (!victim)
         return;
       this.clients.delete(victim.key);
-      stopClientBestEffort(victim.managed.client);
+      this.tombstoneStop(victim.key, victim.managed.client);
     }
   }
   leastRecentlyUsedIdleClient() {
@@ -3440,7 +3512,7 @@ class LspManager {
   async tryDeleteIfOrphaned(key, managed) {
     if (managed.refCount === 0 && managed.pendingWaiters === 0 && !managed.isInitializing && this.clients.get(key) === managed) {
       this.clients.delete(key);
-      await stopClientBestEffort(managed.client);
+      await this.tombstoneStop(key, managed.client);
     }
   }
   async getClient(root, server2, signal) {
@@ -3449,12 +3521,22 @@ class LspManager {
     }
     signal?.throwIfAborted();
     const key = this.getKey(root, server2.id);
+    for (;; ) {
+      const pendingStop = this.pendingStops.get(key);
+      if (pendingStop === undefined)
+        break;
+      await awaitWithSignal2(pendingStop, signal);
+      signal?.throwIfAborted();
+    }
+    if (this.disposed) {
+      throw new Error("LspManager has been disposed");
+    }
     let managed = this.clients.get(key);
     if (managed) {
       const t = this.now();
       if (managed.isInitializing && managed.initializingSince !== null && t - managed.initializingSince > this.initTimeoutMs) {
-        await stopClientBestEffort(managed.client);
         this.clients.delete(key);
+        await this.tombstoneStop(key, managed.client);
         managed = undefined;
       }
     }
@@ -3475,15 +3557,20 @@ class LspManager {
         signal.throwIfAborted();
       }
       if (!managed.client.isAlive()) {
-        await stopClientBestEffort(managed.client);
-        this.clients.delete(key);
+        this.recordDeadGeneration(key);
+        if (this.clients.get(key) === managed) {
+          this.clients.delete(key);
+        }
+        await this.tombstoneStop(key, managed.client);
         return this.getClient(root, server2, signal);
       }
+      this.markHealthyGeneration(key);
       managed.refCount++;
       managed.lastUsedAt = this.now();
       return managed.client;
     }
     this.evictForAdmission();
+    this.ensureRespawnAllowed(key, root, server2.id);
     const client = this.clientFactory(root, server2);
     const initStartedAt = this.now();
     const initPromise = (async () => {
@@ -3507,7 +3594,7 @@ class LspManager {
       if (this.clients.get(key) === newManaged) {
         this.clients.delete(key);
       }
-      await stopClientBestEffort(client);
+      await this.tombstoneStop(key, client);
       throw err;
     }
     newManaged.pendingWaiters--;
@@ -3518,6 +3605,15 @@ class LspManager {
       await this.tryDeleteIfOrphaned(key, newManaged);
       signal.throwIfAborted();
     }
+    if (!client.isAlive()) {
+      this.recordDeadGeneration(key);
+      if (this.clients.get(key) === newManaged) {
+        this.clients.delete(key);
+      }
+      await this.tombstoneStop(key, client);
+      return this.getClient(root, server2, signal);
+    }
+    this.markHealthyGeneration(key);
     newManaged.refCount++;
     newManaged.lastUsedAt = this.now();
     return client;
@@ -3538,15 +3634,20 @@ class LspManager {
     if (client && managed.client !== client)
       return;
     this.clients.delete(key);
-    stopClientBestEffort(managed.client);
+    this.tombstoneStop(key, managed.client);
   }
   warmupClient(root, server2) {
     if (this.disposed)
       return;
     const key = this.getKey(root, server2.id);
-    if (this.clients.has(key))
+    if (this.clients.has(key) || this.pendingStops.has(key))
       return;
     this.evictForAdmission();
+    try {
+      this.ensureRespawnAllowed(key, root, server2.id);
+    } catch {
+      return;
+    }
     const client = this.clientFactory(root, server2);
     const initStartedAt = this.now();
     const initPromise = (async () => {
@@ -3572,7 +3673,7 @@ class LspManager {
       if (this.clients.get(key) === managed) {
         this.clients.delete(key);
       }
-      stopClientBestEffort(client);
+      this.tombstoneStop(key, client);
     });
   }
   isServerInitializing(root, serverId) {
@@ -3616,8 +3717,11 @@ class LspManager {
     for (const managed of this.clients.values()) {
       stopPromises.push(stopClientBestEffort(managed.client));
     }
+    const tombstonedStops = [...this.pendingStops.values()];
     this.clients.clear();
-    await Promise.allSettled(stopPromises);
+    this.respawnBudgets.clear();
+    await Promise.allSettled([...stopPromises, ...tombstonedStops]);
+    this.pendingStops.clear();
   }
 }
 var _defaultInstance = null;
@@ -3627,7 +3731,16 @@ function getLspManager() {
   }
   return _defaultInstance;
 }
-var WORKSPACE_MARKERS = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod", "pom.xml", "build.gradle"];
+var GIT_WORKSPACE_MARKER = ".git";
+var PROJECT_WORKSPACE_MARKERS = [
+  "package.json",
+  "pyproject.toml",
+  "Cargo.toml",
+  "go.mod",
+  "pom.xml",
+  "build.gradle"
+];
+var WORKSPACE_MARKERS = [GIT_WORKSPACE_MARKER, ...PROJECT_WORKSPACE_MARKERS];
 function findWorkspaceRootOutsideContext(directory) {
   const marked = nearestMarkedAncestor(directory);
   if (marked !== undefined)
@@ -4297,20 +4410,25 @@ function findWorkspaceRoot(filePath) {
   if (!isPathInside(cwd, abs))
     return findWorkspaceRootOutsideContext(dir);
   const fallbackRoot = nearestExistingDirectoryInsideContext(dir, cwd) ?? cwd;
+  let nearestPackageRoot;
   while (isPathInside(cwd, dir)) {
     const canonicalDir = existingDirectoryInsideContext(dir, cwd);
     if (canonicalDir !== undefined) {
-      for (const marker of WORKSPACE_MARKERS) {
-        if (existsSync11(join5(dir, marker))) {
-          return canonicalDir;
-        }
+      if (existsSync11(join5(dir, GIT_WORKSPACE_MARKER))) {
+        return canonicalDir;
+      }
+      if (nearestPackageRoot === undefined && hasProjectWorkspaceMarker(dir)) {
+        nearestPackageRoot = canonicalDir;
       }
     }
     if (dir === cwd)
       break;
     dir = dirname10(dir);
   }
-  return fallbackRoot;
+  return nearestPackageRoot ?? fallbackRoot;
+}
+function hasProjectWorkspaceMarker(directory) {
+  return PROJECT_WORKSPACE_MARKERS.some((marker) => existsSync11(join5(directory, marker)));
 }
 function resolveReadablePathInsideContext(filePath) {
   const cwd = contextCwd();

package/packages/omo-codex/plugin/components/lsp/hooks/hooks.json

@@ -8,7 +8,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-tool-use",
 						"timeout": 60,
-						"statusMessage": "(OmO 5.0.0-beta.30) Checking LSP Diagnostics"
+						"statusMessage": "(OmO 5.0.0-beta.32) Checking LSP Diagnostics"
 					}
 				]
 			}
@@ -21,7 +21,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-compact",
 						"timeout": 5,
-						"statusMessage": "(OmO 5.0.0-beta.30) Resetting LSP Diagnostics Cache"
+						"statusMessage": "(OmO 5.0.0-beta.32) Resetting LSP Diagnostics Cache"
 					}
 				]
 			}

package/packages/omo-codex/plugin/components/lsp/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-lsp",
-	"version": "5.0.0-beta.30",
+	"version": "5.0.0-beta.32",
 	"description": "Codex plugin that exposes Language Server Protocol tools and post-edit diagnostics.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",