oh-my-opencode 4.18.1 → 4.19.0

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

@@ -63,18 +63,30 @@ export async function runBridgedCodegraphProcess(
 			resolveExit(signal === null ? 0 : 1);
 		});
 	});
-	const bridgeDone = Promise.all([
-		forwardClientToCodegraph(options.input, childInput, pendingResponses, (mode) => {
-			defaultResponseMode = mode;
-		}),
-		forwardCodegraphToClient(childOutput, options.output, pendingResponses, () => defaultResponseMode),
-	]);
+	const clientForwardingDone = forwardClientToCodegraph(options.input, childInput, pendingResponses, (mode) => {
+		defaultResponseMode = mode;
+	});
+	const responseForwardingDone = forwardCodegraphToClient(
+		childOutput,
+		options.output,
+		pendingResponses,
+		() => defaultResponseMode,
+	);
+	const bridgeDone = Promise.all([clientForwardingDone, responseForwardingDone]);
+	const childAndResponsesDone = Promise.all([childExit, responseForwardingDone]).then(([exitCode]) => exitCode);
 	const destroyChildPipes = (): void => {
 		childInput.destroy();
 		childOutput.destroy();
 	};
 	void childExit.then(destroyChildPipes, destroyChildPipes);
-	return Promise.race([childExit, bridgeDone.then(() => childExit)]);
+	try {
+		return await Promise.race([childAndResponsesDone, bridgeDone.then(() => childExit)]);
+	} catch (error) {
+		destroyChildPipes();
+		if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+		await childExit.catch(() => undefined);
+		throw error;
+	}
 }
 
 async function forwardClientToCodegraph(
@@ -110,14 +122,14 @@ async function forwardCodegraphToClient(
 ): Promise<void> {
 	for await (const message of readStdioJsonRpcMessages(childOutput)) {
 		if (message.kind === "parse_error") {
-			writeStdioJsonRpcResponse(output, errorResponse(null, -32700, "Parse error", message.message), defaultResponseMode());
+			await writeStdioJsonRpcResponse(output, errorResponse(null, -32700, "Parse error", message.message), defaultResponseMode());
 			continue;
 		}
 		const key = responseModeKey(message.payload);
 		const pendingResponse = key === null ? undefined : pendingResponses.get(key);
 		const responseMode = pendingResponse?.responseMode ?? defaultResponseMode();
 		if (key !== null) pendingResponses.delete(key);
-		writeStdioJsonRpcResponse(output, clarifyCodegraphResponse(message.payload, pendingResponse), responseMode);
+		await writeStdioJsonRpcResponse(output, clarifyCodegraphResponse(message.payload, pendingResponse), responseMode);
 	}
 }
 

package/packages/omo-codex/plugin/components/codegraph/test/hook-exclusion.test.ts

@@ -21,7 +21,7 @@ describe("CodeGraph SessionStart exclusion policy", () => {
 		const stdout: string[] = [];
 		const spawned: WorkerSpawnInvocation[] = [];
 		const stateRoot = createAllowedWorkspace("codegraph-omo-state");
-		const workspace = join(stateRoot, ".omo", "ultraresearch", "run", "clones", "repo");
+		const workspace = join(stateRoot, ".omo", "ulw-research", "run", "clones", "repo");
 		mkdirSync(workspace, { recursive: true });
 
 		try {

package/packages/omo-codex/plugin/components/codegraph/test/mcp-bridge-fixtures.ts

@@ -49,6 +49,41 @@ export function writeFakeContractCodegraph(filePath: string): void {
 	chmodSync(filePath, 0o755);
 }
 
+export function writeFakeHeldOpenCodegraph(filePath: string): void {
+	writeFileSync(
+		filePath,
+		[
+			"#!/usr/bin/env node",
+			"const fs = require('node:fs');",
+			"const readline = require('node:readline');",
+			"fs.writeFileSync(process.env.CODEGRAPH_FAKE_LOG, String(process.pid));",
+			"const rl = readline.createInterface({ input: process.stdin });",
+			"rl.once('line', (line) => {",
+			"  const request = JSON.parse(line);",
+			"  process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, result: { ok: true } }) + '\\n');",
+			"});",
+			"setInterval(() => {}, 1000);",
+		].join("\n"),
+	);
+	chmodSync(filePath, 0o755);
+}
+
+export function writeFakeExitingCodegraph(filePath: string): void {
+	writeFileSync(
+		filePath,
+		[
+			"#!/usr/bin/env node",
+			"const readline = require('node:readline');",
+			"const rl = readline.createInterface({ input: process.stdin });",
+			"rl.once('line', (line) => {",
+			"  const request = JSON.parse(line);",
+			"  process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, result: { ok: true } }) + '\\n', () => process.exit(0));",
+			"});",
+		].join("\n"),
+	);
+	chmodSync(filePath, 0o755);
+}
+
 export function frameMcpRequest(request: {
 	readonly id: number;
 	readonly method: string;

package/packages/omo-codex/plugin/components/codegraph/test/serve-mcp-bridge-lifecycle.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it } from "bun:test";
+import { mkdirSync, mkdtempSync, realpathSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { PassThrough, Writable } from "node:stream";
+import { fileURLToPath } from "node:url";
+
+import { runCodegraphServe } from "../src/serve.ts";
+import {
+	frameMcpRequest,
+	writeFakeExitingCodegraph,
+} from "./mcp-bridge-fixtures.ts";
+
+const componentRoot = realpathSync(
+	fileURLToPath(new URL("..", import.meta.url)),
+);
+
+describe("runCodegraphServe MCP bridge lifecycle", () => {
+	it("#given an exiting Codegraph child and delayed closed parent output #when the final response write fails #then the output error is preserved", async () => {
+		const tempRoot = mkdtempSync(
+			join(componentRoot, ".tmp-codegraph-exit-output-failure-"),
+		);
+		const projectRoot = join(tempRoot, "project");
+		const fakeCodegraph = join(tempRoot, "codegraph-exiting.cjs");
+		const input = new PassThrough();
+		const outputError = Object.assign(
+			new Error("parent output closed after child exit"),
+			{ code: "EPIPE" },
+		);
+		const writeStarted = Promise.withResolvers<void>();
+		const output = new Writable({
+			write(_chunk, _encoding, callback) {
+				writeStarted.resolve();
+				setTimeout(() => callback(outputError), 150);
+			},
+		});
+
+		try {
+			mkdirSync(projectRoot, { recursive: true });
+			writeFakeExitingCodegraph(fakeCodegraph);
+			const run = runCodegraphServe({
+				cwd: tempRoot,
+				env: {
+					CODEGRAPH_ALLOW_UNSAFE_NODE: "1",
+					OMO_CODEGRAPH_BIN: fakeCodegraph,
+					OMO_CODEGRAPH_PROJECT_CWD: projectRoot,
+					PATH: process.env["PATH"],
+				},
+				nodeVersion: "22.14.0",
+				buildEnv: () => ({}),
+				resolve: () => ({
+					argsPrefix: [],
+					command: fakeCodegraph,
+					exists: true,
+					source: "env",
+				}),
+				stderr: { write: () => undefined },
+				stdin: input,
+				stdout: output,
+			});
+
+			input.end(frameMcpRequest({ id: 1, method: "tools/list", params: {} }));
+
+			await writeStarted.promise;
+			await expect(run).rejects.toBe(outputError);
+		} finally {
+			rmSync(tempRoot, { recursive: true, force: true });
+		}
+	});
+});

package/packages/omo-codex/plugin/components/codegraph/test/serve-mcp-bridge.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from "bun:test";
 import { mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync } from "node:fs";
 import { join } from "node:path";
-import { PassThrough } from "node:stream";
+import { PassThrough, Writable } from "node:stream";
 import { fileURLToPath } from "node:url";
 
 import { runCodegraphServe } from "../src/serve.ts";
@@ -14,6 +14,7 @@ import {
 	recordValue,
 	stringProperty,
 	writeFakeContractCodegraph,
+	writeFakeHeldOpenCodegraph,
 	writeFakeNewlineCodegraph,
 } from "./mcp-bridge-fixtures.ts";
 
@@ -190,4 +191,59 @@ describe("runCodegraphServe MCP protocol bridge", () => {
 			rmSync(tempRoot, { recursive: true, force: true });
 		}
 	});
+
+	it("#given a held-open Codegraph child and closed parent output #when response forwarding fails #then the child is terminated before rejection", async () => {
+		const tempRoot = mkdtempSync(join(componentRoot, ".tmp-codegraph-output-failure-"));
+		const projectRoot = join(tempRoot, "project");
+		const fakeCodegraph = join(tempRoot, "codegraph-held-open.cjs");
+		const childPidFile = join(tempRoot, "child.pid");
+		const input = new PassThrough();
+		const outputError = Object.assign(new Error("parent output closed"), { code: "EPIPE" });
+		const output = new Writable({
+			write(_chunk, _encoding, callback) {
+				callback(outputError);
+			},
+		});
+		let childPid: number | undefined;
+
+		try {
+			mkdirSync(projectRoot, { recursive: true });
+			writeFakeHeldOpenCodegraph(fakeCodegraph);
+			const run = runCodegraphServe({
+				cwd: tempRoot,
+				env: {
+					CODEGRAPH_ALLOW_UNSAFE_NODE: "1",
+					CODEGRAPH_FAKE_LOG: childPidFile,
+					OMO_CODEGRAPH_BIN: fakeCodegraph,
+					OMO_CODEGRAPH_PROJECT_CWD: projectRoot,
+					PATH: process.env["PATH"],
+				},
+				nodeVersion: "22.14.0",
+				buildEnv: () => ({}),
+				resolve: () => ({ argsPrefix: [], command: fakeCodegraph, exists: true, source: "env" }),
+				stderr: { write: () => undefined },
+				stdin: input,
+				stdout: output,
+			});
+
+			input.end(frameMcpRequest({ id: 1, method: "tools/list", params: {} }));
+
+			await expect(run).rejects.toBe(outputError);
+			childPid = Number(readFileSync(childPidFile, "utf8"));
+			expect(isProcessAlive(childPid)).toBe(false);
+		} finally {
+			if (childPid !== undefined && isProcessAlive(childPid)) process.kill(childPid, "SIGKILL");
+			rmSync(tempRoot, { recursive: true, force: true });
+		}
+	});
 });
+
+function isProcessAlive(pid: number): boolean {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ESRCH") return false;
+		throw error;
+	}
+}

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 4.18.1) Checking Comments"
+						"statusMessage": "(OmO 4.19.0) Checking Comments"
 					}
 				]
 			}

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

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-comment-checker",
-	"version": "4.18.1",
+	"version": "4.19.0",
 	"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 4.18.1) Recommending Git Bash MCP"
+						"statusMessage": "(OmO 4.19.0) Recommending Git Bash MCP"
 					}
 				]
 			}
@@ -20,7 +20,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-compact",
 						"timeout": 5,
-						"statusMessage": "(OmO 4.18.1) Resetting Git Bash MCP Reminder"
+						"statusMessage": "(OmO 4.19.0) 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": "4.18.1",
+	"version": "4.19.0",
 	"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 4.18.1) Verifying LazyCodex Executor Evidence"
+						"statusMessage": "(OmO 4.19.0) 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": "4.18.1",
+	"version": "4.19.0",
 	"description": "Codex SubagentStop evidence verifier for LazyCodex executor completions.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",

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

@@ -3,7 +3,8 @@
 		"lsp": {
 			"command": "node",
 			"args": ["../../../../lsp-daemon/dist/cli.js", "mcp"],
-			"cwd": "."
+			"cwd": ".",
+			"startup_timeout_sec": 10
 		}
 	}
 }

package/packages/omo-codex/plugin/components/lsp/AGENTS.md

@@ -22,4 +22,5 @@ Conventions for humans and agents working on this repository.
 - LSP server processes are owned by `LspManager`.
 - Tool execution acquires clients through `withLspClient(...)` unless it only reports static status.
 - `lsp.rename` mutates files by applying workspace edits; keep it sequential at the MCP caller level.
+- `.mcp.json` sets `lsp` MCP server `startup_timeout_sec: 10` to bound startup; preserve the bound on edits.
 - Do not add pi-coding-agent or omo source dependencies. This package is standalone.

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

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
-  "version": "4.18.1",
-  "inputDigest": "sha256:ce104d23ca60e4a61242e99e54232a9fc82078b6471381511abc3187f8489842",
+  "version": "4.19.0",
+  "inputDigest": "sha256:1c26ab90eb222f050b468e7088ee9e655d0db850605ab425e8636c089a910f79",
   "outputs": [
     {
       "path": "cli.d.ts",
@@ -9,7 +9,7 @@
     },
     {
       "path": "cli.js",
-      "sha256": "84e00d94acd6c757613daaf8dde1e9425861ab6aa16923daaebd207934bc8ca1"
+      "sha256": "e92c3fee5795bf44de9504b0e85c2be208c78a31e966ec9a7a807d621431c74a"
     },
     {
       "path": "codex-hook-cli.d.ts",

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

@@ -13,13 +13,13 @@ import { homedir as homedir3 } from "node:os";
 import { join as join11, resolve as resolve11 } from "node:path";
 
 // ../../../../lsp-daemon/dist/client.js
-import { connect as connect2 } from "node:net";
+import { connect } from "node:net";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { existsSync, realpathSync, statSync } from "node:fs";
 import { basename, delimiter, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { spawn } from "node:child_process";
 import { closeSync as closeSync2, mkdirSync as mkdirSync2, openSync as openSync2 } from "node:fs";
-import { connect } from "node:net";
+import { Socket } from "node:net";
 import { dirname as dirname3 } from "node:path";
 import { execPath } from "node:process";
 import {
@@ -426,42 +426,48 @@ class DaemonUnreachableError extends Error {
 async function ensureDaemonRunning(paths, deps = defaultEnsureDaemonDeps(), options = {}) {
   const readyTimeoutMs = options.readyTimeoutMs ?? DEFAULT_READY_TIMEOUT_MS;
   const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-  if (await deps.probe(paths))
+  const signal = options.signal;
+  throwIfAborted(signal);
+  if (await awaitWithSignal(deps.probe(paths, signal), signal))
     return;
+  throwIfAborted(signal);
   deps.spawnDaemon(paths);
-  await waitUntilReachable(paths, deps, readyTimeoutMs, pollIntervalMs);
+  await waitUntilReachable(paths, deps, readyTimeoutMs, pollIntervalMs, signal);
 }
-async function waitUntilReachable(paths, deps, readyTimeoutMs, pollIntervalMs) {
+async function waitUntilReachable(paths, deps, readyTimeoutMs, pollIntervalMs, signal) {
   const deadline = deps.now() + readyTimeoutMs;
   for (;; ) {
-    if (await deps.probe(paths))
+    throwIfAborted(signal);
+    if (await awaitWithSignal(deps.probe(paths, signal), signal))
       return;
     if (deps.now() >= deadline)
       throw new DaemonUnreachableError(paths.socket);
-    await deps.sleep(pollIntervalMs);
+    await awaitWithSignal(deps.sleep(pollIntervalMs, signal), signal);
   }
 }
-async function probeDaemon(paths, timeoutMs = PROBE_TIMEOUT_MS) {
+async function probeDaemon(paths, timeoutMs = PROBE_TIMEOUT_MS, signal) {
   const token = readAuthToken(paths);
   if (!token)
     return false;
-  return await pingDaemon(paths, token, timeoutMs) !== null;
+  return await pingDaemon(paths, token, timeoutMs, signal) !== null;
 }
-function pingDaemon(paths, token, timeoutMs = PROBE_TIMEOUT_MS) {
+function pingDaemon(paths, token, timeoutMs = PROBE_TIMEOUT_MS, signal) {
   return new Promise((resolve22) => {
-    const socket = connect(paths.socket);
+    const socket = new Socket;
     let settled = false;
+    let timer;
     const finish = (value) => {
       if (settled)
         return;
       settled = true;
+      if (timer !== undefined)
+        clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
       socket.destroy();
       resolve22(value);
     };
-    const timer = setTimeout(() => finish(null), timeoutMs);
-    timer.unref?.();
+    const onAbort = () => finish(null);
     const decoder = createLineDecoder((message) => {
-      clearTimeout(timer);
       finish(parsePingResponse(message));
     });
     socket.once("connect", () => {
@@ -469,9 +475,16 @@ function pingDaemon(paths, token, timeoutMs = PROBE_TIMEOUT_MS) {
     });
     socket.on("data", (chunk) => decoder.push(chunk));
     socket.once("error", () => {
-      clearTimeout(timer);
       finish(null);
     });
+    timer = setTimeout(() => finish(null), timeoutMs);
+    timer.unref?.();
+    if (signal?.aborted) {
+      onAbort();
+      return;
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+    socket.connect(paths.socket);
   });
 }
 function spawnDaemonProcess(paths) {
@@ -489,14 +502,62 @@ function spawnDaemonProcess(paths) {
 }
 function defaultEnsureDaemonDeps() {
   return {
-    probe: (paths) => probeDaemon(paths),
+    probe: (paths, signal) => probeDaemon(paths, PROBE_TIMEOUT_MS, signal),
     spawnDaemon: (paths) => spawnDaemonProcess(paths),
-    sleep: (ms) => new Promise((resolve22) => {
-      setTimeout(resolve22, ms);
-    }),
+    sleep: (ms, signal) => sleepWithSignal(ms, signal),
     now: () => Date.now()
   };
 }
+function sleepWithSignal(ms, signal) {
+  return new Promise((resolve22) => {
+    let settled = false;
+    const finish = () => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", finish);
+      resolve22();
+    };
+    const timer = setTimeout(finish, ms);
+    if (signal?.aborted) {
+      finish();
+      return;
+    }
+    signal?.addEventListener("abort", finish, { once: true });
+  });
+}
+function awaitWithSignal(promise, signal) {
+  if (!signal)
+    return promise;
+  if (signal.aborted)
+    return Promise.reject(abortError(signal));
+  return new Promise((resolve22, reject) => {
+    let settled = false;
+    const finish = (run) => {
+      if (settled)
+        return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      run();
+    };
+    const onAbort = () => finish(() => reject(abortError(signal)));
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then((value) => finish(() => resolve22(value)), (error) => finish(() => reject(error)));
+  });
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted)
+    throw abortError(signal);
+}
+function abortError(signal) {
+  const reason = signal.reason;
+  if (reason instanceof Error)
+    return reason;
+  const error = new Error(typeof reason === "string" ? reason : "daemon startup cancelled");
+  error.name = "AbortError";
+  return error;
+}
 function parsePingResponse(message) {
   if (!message || typeof message !== "object" || Array.isArray(message))
     return null;
@@ -692,7 +753,7 @@ class JsonRpcConnection {
         settled = true;
         this.pendingRequests.delete(key);
         cleanup();
-        const rejectCancelled = () => reject(abortError(options.signal));
+        const rejectCancelled = () => reject(abortError2(options.signal));
         if (!requestWritten) {
           cancelAfterWrite = true;
           rejectCancelled();
@@ -896,7 +957,7 @@ ${body}`;
     }
   }
 }
-function abortError(signal) {
+function abortError2(signal) {
   const reason = signal?.reason;
   if (reason instanceof Error)
     return reason;
@@ -3118,11 +3179,11 @@ function waitForDiagnosticsActivity(wait, signal) {
   if (!signal)
     return wait;
   if (signal.aborted)
-    return Promise.reject(abortError2(signal));
+    return Promise.reject(abortError3(signal));
   return new Promise((resolve72, reject) => {
     const onAbort = () => {
       signal.removeEventListener("abort", onAbort);
-      reject(abortError2(signal));
+      reject(abortError3(signal));
     };
     signal.addEventListener("abort", onAbort, { once: true });
     wait.then(() => {
@@ -3157,7 +3218,7 @@ function preCommitAbortReason(source) {
     return reason;
   return new Error("LSP request cancelled before workspace edit commit");
 }
-function abortError2(signal) {
+function abortError3(signal) {
   const reason = signal.reason;
   if (reason instanceof Error)
     return reason;
@@ -3188,7 +3249,7 @@ async function stopClientBestEffort(client) {
     reportBestEffortCleanupError("client stop", error);
   }
 }
-function awaitWithSignal(promise, signal) {
+function awaitWithSignal2(promise, signal) {
   if (!signal)
     return promise;
   return new Promise((resolve72, reject) => {
@@ -3291,7 +3352,7 @@ class LspManager {
       if (managed.initPromise) {
         managed.pendingWaiters++;
         try {
-          await awaitWithSignal(managed.initPromise, signal);
+          await awaitWithSignal2(managed.initPromise, signal);
         } catch (err) {
           managed.pendingWaiters--;
           await this.tryDeleteIfOrphaned(key, managed);
@@ -3329,7 +3390,7 @@ class LspManager {
     };
     this.clients.set(key, newManaged);
     try {
-      await awaitWithSignal(initPromise, signal);
+      await awaitWithSignal2(initPromise, signal);
     } catch (err) {
       newManaged.pendingWaiters--;
       if (this.clients.get(key) === newManaged) {
@@ -4280,7 +4341,7 @@ async function aggregateDiagnosticsForDirectory(directory, extension, severity,
   const fileErrors = [];
   const maxConcurrency = Math.max(1, options.maxConcurrency ?? DIRECTORY_DIAGNOSTICS_MAX_CONCURRENCY);
   options.signal?.throwIfAborted();
-  const client = await manager.getClient(root, server2);
+  const client = await manager.getClient(root, server2, options.signal);
   try {
     let nextIndex = 0;
     const workers = Array.from({ length: Math.min(maxConcurrency, filesToProcess.length) }, async () => {
@@ -4960,14 +5021,14 @@ class DaemonRequestCancelledError extends DaemonRequestError {
 async function callToolViaDaemon(name, args, options) {
   const context = requireContext(options.context);
   const paths = options.paths ?? daemonPaths();
-  const ensure = options.ensure ?? ensureDaemonRunning;
+  const ensure = options.ensure ?? ((ensurePaths, signal) => ensureDaemonRunning(ensurePaths, undefined, signal === undefined ? {} : { signal }));
   const timeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
   const requestArgs = withContext(args, context);
   let lastError;
   let authRefreshUsed = false;
   for (let attempt = 0;attempt < 3; attempt += 1) {
     try {
-      await ensure(paths);
+      await ensureDaemonAvailable(paths, ensure, options.signal);
       const token = readAuthToken(paths);
       if (!token)
         throw new DaemonRequestError("daemon auth token missing", false);
@@ -4998,6 +5059,27 @@ function requireContext(context) {
 function withContext(args, context) {
   return { ...args, [CONTEXT_KEY]: context };
 }
+function ensureDaemonAvailable(paths, ensure, signal) {
+  if (!signal)
+    return ensure(paths);
+  return new Promise((resolve9, reject) => {
+    let settled = false;
+    const finish = (run) => {
+      if (settled)
+        return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      run();
+    };
+    const onAbort = () => finish(() => reject(new DaemonRequestCancelledError(false)));
+    if (signal.aborted) {
+      onAbort();
+      return;
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
+    Promise.resolve().then(() => ensure(paths, signal)).then(() => finish(() => resolve9()), (error) => finish(() => reject(signal.aborted ? new DaemonRequestCancelledError(false) : error)));
+  });
+}
 function daemonUnreachableResult(paths, error) {
   const text2 = [
     `LSP daemon unreachable: ${errorText(error)}.`,
@@ -5011,7 +5093,7 @@ function daemonUnreachableResult(paths, error) {
 }
 function sendToolCall(paths, token, name, args, options) {
   return new Promise((resolve9, reject) => {
-    const socket = connect2(paths.socket);
+    const socket = connect(paths.socket);
     const requestId = allocateProxyRequestId();
     let settled = false;
     let requestWritten = false;

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 4.18.1) Checking LSP Diagnostics"
+						"statusMessage": "(OmO 4.19.0) Checking LSP Diagnostics"
 					}
 				]
 			}
@@ -21,7 +21,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-compact",
 						"timeout": 5,
-						"statusMessage": "(OmO 4.18.1) Resetting LSP Diagnostics Cache"
+						"statusMessage": "(OmO 4.19.0) Resetting LSP Diagnostics Cache"
 					}
 				]
 			}

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

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