oh-my-opencode 4.19.0 → 4.19.2

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

@@ -5,6 +5,7 @@ import { dirname, join, resolve } from "node:path";
 import { Readable, Writable } from "node:stream";
 import { fileURLToPath } from "node:url";
 
+import { CODEGRAPH_PINNED_VERSION } from "../../../../../utils/src/codegraph/manifest.ts";
 import { resolveServeProcessInvocation, runCodegraphServe } from "../src/serve.ts";
 
 const componentRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
@@ -27,12 +28,6 @@ describe("runCodegraphServe", () => {
 			env: { CUSTOM: "drop", HOME: "/tmp/home", OPENAI_API_KEY: "sk-test-secret" },
 			nodeVersion: "22.14.0",
 			homeDir: "/tmp/home",
-			buildEnv: ({ homeDir }) => ({
-				CODEGRAPH_INSTALL_DIR: `${homeDir}/.omo/codegraph`,
-				CODEGRAPH_NO_DOWNLOAD: "1",
-				CODEGRAPH_TELEMETRY: "0",
-				DO_NOT_TRACK: "1",
-			}),
 			resolve: () => ({ argsPrefix: ["shim.js"], command: "node", exists: true, source: "bundled" }),
 			runProcess: (
 				command: string,
@@ -53,7 +48,58 @@ describe("runCodegraphServe", () => {
 				command: "node",
 				cwd: resolve(runCwd),
 				env: {
-					CODEGRAPH_INSTALL_DIR: "/tmp/home/.omo/codegraph",
+					CODEGRAPH_INSTALL_DIR: join("/tmp/home", ".omo", "codegraph"),
+					CODEGRAPH_NO_DOWNLOAD: "1",
+					CODEGRAPH_TELEMETRY: "0",
+					DO_NOT_TRACK: "1",
+					HOME: "/tmp/home",
+				},
+				stdio: "pipe",
+			},
+		]);
+		expect(calls[0]?.env["CUSTOM"]).toBeUndefined();
+		expect(calls[0]?.env["OPENAI_API_KEY"]).toBeUndefined();
+	});
+
+	it("#given codegraph.daemon=false #when serving MCP #then CODEGRAPH_NO_DAEMON pins daemon-off", async () => {
+		// given
+		const runCwd = componentRoot;
+		const calls: Array<{
+			readonly args: readonly string[];
+			readonly command: string;
+			readonly cwd: string;
+			readonly env: Record<string, string | undefined>;
+			readonly stdio: "pipe";
+		}> = [];
+
+		// when
+		const exitCode = await runCodegraphServe({
+			config: { codegraph: { daemon: false, enabled: true }, sources: [], warnings: [] },
+			cwd: runCwd,
+			env: { CUSTOM: "drop", HOME: "/tmp/home", OPENAI_API_KEY: "sk-test-secret" },
+			nodeVersion: "22.14.0",
+			homeDir: "/tmp/home",
+			resolve: () => ({ argsPrefix: ["shim.js"], command: "node", exists: true, source: "bundled" }),
+			runProcess: (
+				command: string,
+				args: readonly string[],
+				options: { readonly cwd: string; readonly env: Record<string, string | undefined>; readonly stdio: "pipe" },
+			) => {
+				calls.push({ args, command, cwd: options.cwd, env: options.env, stdio: options.stdio });
+				return Promise.resolve(7);
+			},
+			stderr: { write: () => undefined },
+		});
+
+		// then
+		expect(exitCode).toBe(7);
+		expect(calls).toEqual([
+			{
+				args: ["shim.js", "serve", "--mcp"],
+				command: "node",
+				cwd: resolve(runCwd),
+				env: {
+					CODEGRAPH_INSTALL_DIR: join("/tmp/home", ".omo", "codegraph"),
 					CODEGRAPH_NO_DAEMON: "1",
 					CODEGRAPH_NO_DOWNLOAD: "1",
 					CODEGRAPH_TELEMETRY: "0",
@@ -63,6 +109,7 @@ describe("runCodegraphServe", () => {
 				stdio: "pipe",
 			},
 		]);
+		expect(calls[0]?.env["CODEGRAPH_NO_DAEMON"]).toBe("1");
 		expect(calls[0]?.env["CUSTOM"]).toBeUndefined();
 		expect(calls[0]?.env["OPENAI_API_KEY"]).toBeUndefined();
 	});
@@ -136,12 +183,12 @@ describe("runCodegraphServe", () => {
 		expect(spawned).toEqual([{ args: ["serve", "--mcp"], command: commandPath }]);
 	});
 
-	it("#given Windows Codex SOT install_dir has codegraph.cmd #when serving MCP #then it resolves there and exports CODEGRAPH_INSTALL_DIR", async () => {
-		await withProcessPlatform("win32", async () => {
+	it("#given Codex SOT install_dir has the pinned launcher and daemon is omitted #when serving MCP #then it defaults daemon-on", async () => {
+		await withProcessPlatform(process.platform, async () => {
 			// given
 			const tempRoot = mkdtempSync(join(tmpdir(), "omo-codegraph-serve-install-dir-"));
 			const installDir = join(tempRoot, "custom-codegraph");
-			const binPath = join(installDir, "bin", "codegraph.cmd");
+			const binPath = join(installDir, "bin", process.platform === "win32" ? "codegraph.cmd" : "codegraph");
 			const calls: Array<{
 				readonly args: readonly string[];
 				readonly command: string;
@@ -150,7 +197,12 @@ describe("runCodegraphServe", () => {
 
 			try {
 				mkdirSync(join(installDir, "bin"), { recursive: true });
+				mkdirSync(join(installDir, ".provisioned"), { recursive: true });
 				writeFileSync(binPath, "");
+				writeFileSync(
+					join(installDir, ".provisioned", `codegraph-${CODEGRAPH_PINNED_VERSION}.json`),
+					`${JSON.stringify({ binPath, version: CODEGRAPH_PINNED_VERSION })}\n`,
+				);
 
 				// when
 				const exitCode = await runCodegraphServe({
@@ -169,6 +221,65 @@ describe("runCodegraphServe", () => {
 					stderr: { write: () => undefined },
 				});
 
+				// then
+				expect(exitCode).toBe(0);
+				expect(calls).toEqual([
+					{
+						args: ["serve", "--mcp"],
+						command: binPath,
+						env: {
+							CODEGRAPH_INSTALL_DIR: installDir,
+							CODEGRAPH_NO_DOWNLOAD: "1",
+							CODEGRAPH_TELEMETRY: "0",
+							DO_NOT_TRACK: "1",
+							HOME: "/tmp/home",
+						},
+					},
+				]);
+			} finally {
+				rmSync(tempRoot, { recursive: true, force: true });
+			}
+		});
+	});
+
+	it("#given Codex SOT install_dir with codegraph.daemon=false #when serving MCP #then CODEGRAPH_NO_DAEMON pins daemon-off", async () => {
+		await withProcessPlatform(process.platform, async () => {
+			// given
+			const tempRoot = mkdtempSync(join(tmpdir(), "omo-codegraph-serve-install-dir-daemon-"));
+			const installDir = join(tempRoot, "custom-codegraph");
+			const binPath = join(installDir, "bin", process.platform === "win32" ? "codegraph.cmd" : "codegraph");
+			const calls: Array<{
+				readonly args: readonly string[];
+				readonly command: string;
+				readonly env: Record<string, string | undefined>;
+			}> = [];
+
+			try {
+				mkdirSync(join(installDir, "bin"), { recursive: true });
+				mkdirSync(join(installDir, ".provisioned"), { recursive: true });
+				writeFileSync(binPath, "");
+				writeFileSync(
+					join(installDir, ".provisioned", `codegraph-${CODEGRAPH_PINNED_VERSION}.json`),
+					`${JSON.stringify({ binPath, version: CODEGRAPH_PINNED_VERSION })}\n`,
+				);
+
+				// when
+				const exitCode = await runCodegraphServe({
+					config: { codegraph: { daemon: false, enabled: true, install_dir: installDir }, sources: [], trustedCodegraphInstallDir: installDir, warnings: [] },
+					env: { HOME: "/tmp/home" },
+					nodeVersion: "22.14.0",
+					homeDir: "/tmp/home",
+					resolve: (options) => {
+						const provisioned = options.provisioned?.();
+						return { argsPrefix: [], command: provisioned ?? "missing", exists: provisioned !== null && provisioned !== undefined, source: "provisioned" };
+					},
+					runProcess: (command, args, options) => {
+						calls.push({ args, command, env: options.env });
+						return Promise.resolve(0);
+					},
+					stderr: { write: () => undefined },
+				});
+
 				// then
 				expect(exitCode).toBe(0);
 				expect(calls).toEqual([
@@ -185,6 +296,7 @@ describe("runCodegraphServe", () => {
 						},
 					},
 				]);
+				expect(calls[0]?.env["CODEGRAPH_NO_DAEMON"]).toBe("1");
 			} finally {
 				rmSync(tempRoot, { recursive: true, force: true });
 			}

package/packages/omo-codex/plugin/components/codegraph/test/session-start-node-support.test.ts

@@ -52,7 +52,7 @@ describe("CodeGraph SessionStart worker Node support", () => {
 		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-node-provision-home-"));
 		const binPath = join(homeDir, ".omo", "codegraph", "bin", "codegraph");
 		const calls: Array<{ readonly args: readonly string[]; readonly command: string }> = [];
-		const provisionCalls: Array<{ readonly installDir?: string; readonly lockDir: string; readonly version: "1.0.1" }> = [];
+		const provisionCalls: Array<{ readonly installDir?: string; readonly lockDir: string; readonly version: "1.4.1" }> = [];
 		const outcomes: unknown[] = [];
 
 		try {
@@ -90,7 +90,7 @@ describe("CodeGraph SessionStart worker Node support", () => {
 				{ args: ["init"], command: binPath },
 			]);
 			expect(provisionCalls).toEqual([
-				{ installDir: join(homeDir, ".omo", "codegraph"), lockDir: join(homeDir, ".omo", "codegraph", ".locks"), version: "1.0.1" },
+				{ installDir: join(homeDir, ".omo", "codegraph"), lockDir: join(homeDir, ".omo", "codegraph", ".locks"), version: "1.4.1" },
 			]);
 			expect(outcomes).toEqual([{ action: "initialized", exitCode: 0, projectRoot: workspace, source: "provisioned", timedOut: false }]);
 		} finally {

package/packages/omo-codex/plugin/components/codegraph/test/session-start-worker-flow.test.ts

@@ -3,66 +3,70 @@ import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "nod
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
+import { CODEGRAPH_PINNED_VERSION } from "../../../../../utils/src/codegraph/manifest.ts";
 import { resolveCodegraphCommandInvocation, runCodegraphSessionStartWorker } from "../src/hook.ts";
 
 describe("CodeGraph SessionStart worker flow", () => {
-	it("#given Windows install_dir has codegraph.cmd #when worker resolves provisioned CodeGraph #then it uses the cmd shim", async () => {
-		await withProcessPlatform("win32", async () => {
-			// given
-			const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-win32-"));
-			const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-win32-home-"));
-			const installDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-win32-install-"));
-			const binPath = join(installDir, "bin", "codegraph.cmd");
-			const calls: { readonly args: readonly string[]; readonly command: string; readonly env: Record<string, string> }[] = [];
-			const outcomes: unknown[] = [];
-			try {
-				mkdirSync(join(installDir, "bin"), { recursive: true });
-				writeFileSync(binPath, "");
+	it("#given install_dir has the pinned platform binary #when worker resolves provisioned CodeGraph #then it uses that launcher", async () => {
+		// given
+		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-platform-"));
+		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-platform-home-"));
+		const installDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-platform-install-"));
+		const binPath = join(installDir, "bin", process.platform === "win32" ? "codegraph.cmd" : "codegraph");
+		const calls: { readonly args: readonly string[]; readonly command: string; readonly env: Record<string, string> }[] = [];
+		const outcomes: unknown[] = [];
+		try {
+			mkdirSync(join(installDir, "bin"), { recursive: true });
+			mkdirSync(join(installDir, ".provisioned"), { recursive: true });
+			writeFileSync(binPath, "");
+			writeFileSync(
+				join(installDir, ".provisioned", `codegraph-${CODEGRAPH_PINNED_VERSION}.json`),
+				`${JSON.stringify({ binPath, version: CODEGRAPH_PINNED_VERSION })}\n`,
+			);
 
-				// when
-				const result = await runCodegraphSessionStartWorker({
-					config: { codegraph: { enabled: true, install_dir: installDir }, sources: [], trustedCodegraphInstallDir: installDir, warnings: [] },
-					nodeVersion: "22.14.0",
-					cwd: workspace,
-					env: { HOME: homeDir },
-					logOutcome: (outcome) => outcomes.push(outcome),
-					deps: {
-						ensureGitignored: () => true,
-						ensureProvisioned: () => {
-							throw new Error("provisioning should not run when install_dir binary exists");
-						},
-						prepareWorkspace: () => ({
-							dataDir: join(homeDir, ".omo/codegraph/projects/test"),
-							dataRoot: join(homeDir, ".omo/codegraph"),
-							linked: true,
-							mode: "global-linked",
-							projectLink: join(workspace, ".codegraph"),
-						}),
-						resolveCommand: (options) => {
-							const provisioned = options?.provisioned?.() ?? null;
-							return { argsPrefix: [], command: provisioned ?? "missing-codegraph", exists: provisioned !== null, source: provisioned === null ? "path" : "provisioned" };
-						},
-						runCommand: (_projectRoot, command, args, options) => {
-							calls.push({ args, command, env: options.env });
-							return Promise.resolve({ exitCode: 0, stdout: calls.length === 1 ? '{"initialized":false}' : "", timedOut: false });
-						},
+			// when
+			const result = await runCodegraphSessionStartWorker({
+				config: { codegraph: { enabled: true, install_dir: installDir }, sources: [], trustedCodegraphInstallDir: installDir, warnings: [] },
+				nodeVersion: "22.14.0",
+				cwd: workspace,
+				env: { HOME: homeDir },
+				logOutcome: (outcome) => outcomes.push(outcome),
+				deps: {
+					ensureGitignored: () => true,
+					ensureProvisioned: () => {
+						throw new Error("provisioning should not run when install_dir binary exists");
 					},
-				});
+					prepareWorkspace: () => ({
+						dataDir: join(homeDir, ".omo/codegraph/projects/test"),
+						dataRoot: join(homeDir, ".omo/codegraph"),
+						linked: true,
+						mode: "global-linked",
+						projectLink: join(workspace, ".codegraph"),
+					}),
+					resolveCommand: (options) => {
+						const provisioned = options?.provisioned?.() ?? null;
+						return { argsPrefix: [], command: provisioned ?? "missing-codegraph", exists: provisioned !== null, source: provisioned === null ? "path" : "provisioned" };
+					},
+					runCommand: (_projectRoot, command, args, options) => {
+						calls.push({ args, command, env: options.env });
+						return Promise.resolve({ exitCode: 0, stdout: calls.length === 1 ? '{"initialized":false}' : "", timedOut: false });
+					},
+				},
+			});
 
-				// then
-				expect(result).toEqual({ action: "initialized" });
-				expect(calls.map((call) => ({ args: [...call.args], command: call.command }))).toEqual([
-					{ args: ["status", "--json"], command: binPath },
-					{ args: ["init"], command: binPath },
-				]);
-				expect(calls[0]?.env["CODEGRAPH_INSTALL_DIR"]).toBe(installDir);
-				expect(outcomes).toEqual([{ action: "initialized", exitCode: 0, projectRoot: workspace, source: "provisioned", timedOut: false }]);
-			} finally {
-				rmSync(workspace, { recursive: true, force: true });
-				rmSync(homeDir, { recursive: true, force: true });
-				rmSync(installDir, { recursive: true, force: true });
-			}
-		});
+			// then
+			expect(result).toEqual({ action: "initialized" });
+			expect(calls.map((call) => ({ args: [...call.args], command: call.command }))).toEqual([
+				{ args: ["status", "--json"], command: binPath },
+				{ args: ["init"], command: binPath },
+			]);
+			expect(calls[0]?.env["CODEGRAPH_INSTALL_DIR"]).toBe(installDir);
+			expect(outcomes).toEqual([{ action: "initialized", exitCode: 0, projectRoot: workspace, source: "provisioned", timedOut: false }]);
+		} finally {
+			rmSync(workspace, { recursive: true, force: true });
+			rmSync(homeDir, { recursive: true, force: true });
+			rmSync(installDir, { recursive: true, force: true });
+		}
 	});
 
 	it("#given Windows codegraph.cmd #when default worker runner builds invocation #then it runs through cmd.exe", () => {
@@ -152,6 +156,49 @@ describe("CodeGraph SessionStart worker flow", () => {
 		}
 	});
 
+	it("#given codegraph.daemon=true #when the indexing worker runs #then its env stays daemon-less with CODEGRAPH_NO_DAEMON=1", async () => {
+		// given
+		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-daemon-"));
+		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-daemon-home-"));
+		const calls: { readonly args: readonly string[]; readonly command: string; readonly env: Record<string, string> }[] = [];
+		try {
+			// when
+			const result = await runCodegraphSessionStartWorker({
+				config: { codegraph: { daemon: true, enabled: true, install_dir: "/tmp/codegraph-install" }, sources: [], trustedCodegraphInstallDir: "/tmp/codegraph-install", warnings: [] },
+				nodeVersion: "22.14.0",
+				cwd: workspace,
+				env: { HOME: homeDir },
+				logOutcome: () => undefined,
+				deps: {
+					ensureGitignored: () => true,
+					ensureProvisioned: () => Promise.resolve({ binPath: "/tmp/codegraph", provisioned: true }),
+					prepareWorkspace: () => ({
+						dataDir: join(homeDir, ".omo/codegraph/projects/test"),
+						dataRoot: join(homeDir, ".omo/codegraph"),
+						linked: true,
+						mode: "global-linked",
+						projectLink: join(workspace, ".codegraph"),
+					}),
+					resolveCommand: () => ({ argsPrefix: [], command: "/tmp/codegraph", exists: true, source: "path" }),
+					runCommand: (_projectRoot, command, args, options) => {
+						calls.push({ args, command, env: options.env });
+						return Promise.resolve({ exitCode: 0, stdout: calls.length === 1 ? '{"initialized":true}' : "", timedOut: false });
+					},
+				},
+			});
+
+			// then
+			expect(result).toEqual({ action: "synced" });
+			expect(calls.length).toBeGreaterThan(0);
+			for (const call of calls) {
+				expect(call.env["CODEGRAPH_NO_DAEMON"]).toBe("1");
+			}
+		} finally {
+			rmSync(workspace, { recursive: true, force: true });
+			rmSync(homeDir, { recursive: true, force: true });
+		}
+	});
+
 	it("#given ambient provider tokens #when default worker runner spawns CodeGraph #then child env only gets safe and controlled variables", async () => {
 		// given
 		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-env-"));
@@ -208,13 +255,3 @@ describe("CodeGraph SessionStart worker flow", () => {
 		}
 	});
 });
-
-async function withProcessPlatform(platform: NodeJS.Platform, run: () => Promise<void>): Promise<void> {
-	const descriptor = Object.getOwnPropertyDescriptor(process, "platform");
-	Object.defineProperty(process, "platform", { configurable: true, enumerable: true, value: platform });
-	try {
-		await run();
-	} finally {
-		if (descriptor !== undefined) Object.defineProperty(process, "platform", descriptor);
-	}
-}

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.19.0) Checking Comments"
+						"statusMessage": "(OmO 4.19.2) Checking Comments"
 					}
 				]
 			}

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

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-comment-checker",
-	"version": "4.19.0",
+	"version": "4.19.2",
 	"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.19.0) Recommending Git Bash MCP"
+						"statusMessage": "(OmO 4.19.2) 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.19.0) Resetting Git Bash MCP Reminder"
+						"statusMessage": "(OmO 4.19.2) 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.19.0",
+	"version": "4.19.2",
 	"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.19.0) Verifying LazyCodex Executor Evidence"
+						"statusMessage": "(OmO 4.19.2) 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.19.0",
+	"version": "4.19.2",
 	"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": "4.19.0",
-  "inputDigest": "sha256:1c26ab90eb222f050b468e7088ee9e655d0db850605ab425e8636c089a910f79",
+  "version": "4.19.2",
+  "inputDigest": "sha256:e3b790af9754f934c7eeebe6a7d023ac12cdff1e9f8f519e30fbcb53ada9ac14",
   "outputs": [
     {
       "path": "cli.d.ts",
@@ -9,7 +9,7 @@
     },
     {
       "path": "cli.js",
-      "sha256": "e92c3fee5795bf44de9504b0e85c2be208c78a31e966ec9a7a807d621431c74a"
+      "sha256": "f46b15e830f85d0d6f46e0b36c726de2fd56adc43b1cd4660430db86352a8f37"
     },
     {
       "path": "codex-hook-cli.d.ts",

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

@@ -212,6 +212,78 @@ function errorCode(error) {
 function isPlainRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+
+class DaemonRequestError extends Error {
+  requestWritten;
+  constructor(message, requestWritten) {
+    super(message);
+    this.name = "DaemonRequestError";
+    this.requestWritten = requestWritten;
+  }
+}
+
+class DaemonAuthenticationRejectedError extends DaemonRequestError {
+  constructor() {
+    super("daemon authentication failed before dispatch", true);
+    this.name = "DaemonAuthenticationRejectedError";
+  }
+}
+
+class DaemonRequestCancelledError extends DaemonRequestError {
+  constructor(requestWritten) {
+    super("daemon request cancelled", requestWritten);
+    this.name = "DaemonRequestCancelledError";
+  }
+}
+
+class DaemonRequestTimedOutError extends DaemonRequestError {
+  timeoutMs;
+  constructor(requestWritten, timeoutMs) {
+    super("daemon request timed out", requestWritten);
+    this.name = "DaemonRequestTimedOutError";
+    this.timeoutMs = timeoutMs;
+  }
+}
+function daemonFailureResult(paths, error) {
+  if (error instanceof DaemonRequestCancelledError)
+    return daemonCancelledResult(paths);
+  if (error instanceof DaemonRequestTimedOutError)
+    return daemonTimedOutResult(paths, error.timeoutMs);
+  return daemonUnreachableResult(paths, error);
+}
+function daemonCancelledResult(paths) {
+  const text = [
+    "LSP daemon request cancelled: the caller aborted this request (for example, the turn was interrupted).",
+    "The daemon stays available; no LSP work was applied. Retry when you are ready.",
+    `Socket: ${paths.socket}`
+  ].join(`
+`);
+  return { content: [{ type: "text", text }], isError: true };
+}
+function daemonTimedOutResult(paths, timeoutMs) {
+  const text = [
+    `LSP daemon request timed out after ${timeoutMs}ms: the daemon did not respond in time.`,
+    "The daemon stays available but may be busy. Retry when you are ready.",
+    `Socket: ${paths.socket}`,
+    `Logs: ${paths.log}`
+  ].join(`
+`);
+  return { content: [{ type: "text", text }], isError: true };
+}
+function daemonUnreachableResult(paths, error) {
+  const text = [
+    `LSP daemon unreachable: ${errorText(error)}.`,
+    "The MCP server is a thin proxy and never runs language servers in-process.",
+    `Socket: ${paths.socket}`,
+    `Logs: ${paths.log}`,
+    "The daemon is auto-started on demand and will be retried on the next request."
+  ].join(`
+`);
+  return { content: [{ type: "text", text }], isError: true };
+}
+function errorText(error) {
+  return error instanceof Error ? error.message : String(error);
+}
 var OMO_DAEMON_PROTOCOL_VERSION = 1;
 var AUTH_ERROR_CODE = -32001;
 function authEnvelope(token) {
@@ -3134,8 +3206,13 @@ class LspClient extends LspClientConnection {
       if (!pushFallbackOnly)
         continue;
       const remainingMs = deadlineAt - Date.now();
-      if (remainingMs <= 0)
+      if (remainingMs <= 0) {
+        if (!this.isDiagnosticPullSupported() && snapshot.publishGeneration === 0) {
+          const cached = this.documents.getPullCache(snapshot);
+          return { items: cached === null ? [] : [...cached.diagnostics] };
+        }
         return this.freshnessTimeout(absPath);
+      }
       const waitMs = push.status === "wait" ? Math.min(push.waitMs, remainingMs) : remainingMs;
       await waitForDiagnosticsActivity(this.documents.waitForDiagnosticsActivity(snapshot, waitMs), signal);
     }
@@ -4995,29 +5072,6 @@ var LSP_MCP_TOOLS = [
 var CONTEXT_KEY = "_context";
 var DEFAULT_REQUEST_TIMEOUT_MS = 30000;
 var nextProxyRequestId = 1;
-
-class DaemonRequestError extends Error {
-  requestWritten;
-  constructor(message, requestWritten) {
-    super(message);
-    this.name = "DaemonRequestError";
-    this.requestWritten = requestWritten;
-  }
-}
-
-class DaemonAuthenticationRejectedError extends DaemonRequestError {
-  constructor() {
-    super("daemon authentication failed before dispatch", true);
-    this.name = "DaemonAuthenticationRejectedError";
-  }
-}
-
-class DaemonRequestCancelledError extends DaemonRequestError {
-  constructor(requestWritten) {
-    super("daemon request cancelled", requestWritten);
-    this.name = "DaemonRequestCancelledError";
-  }
-}
 async function callToolViaDaemon(name, args, options) {
   const context = requireContext(options.context);
   const paths = options.paths ?? daemonPaths();
@@ -5046,7 +5100,7 @@ async function callToolViaDaemon(name, args, options) {
         break;
     }
   }
-  return daemonUnreachableResult(paths, lastError);
+  return daemonFailureResult(paths, lastError);
 }
 function callDiagnosticsViaDaemon(filePath, options) {
   return callToolViaDaemon("diagnostics", { filePath, severity: "error" }, options);
@@ -5080,17 +5134,6 @@ function ensureDaemonAvailable(paths, ensure, signal) {
     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)}.`,
-    "The MCP server is a thin proxy and never runs language servers in-process.",
-    `Socket: ${paths.socket}`,
-    `Logs: ${paths.log}`,
-    "The daemon is auto-started on demand and will be retried on the next request."
-  ].join(`
-`);
-  return { content: [{ type: "text", text: text2 }], isError: true };
-}
 function sendToolCall(paths, token, name, args, options) {
   return new Promise((resolve9, reject) => {
     const socket = connect(paths.socket);
@@ -5130,7 +5173,7 @@ function sendToolCall(paths, token, name, args, options) {
     };
     const timer = setTimeout(() => {
       sendCancel();
-      finish(() => reject(new DaemonRequestError("daemon request timed out", requestWritten)));
+      finish(() => reject(new DaemonRequestTimedOutError(requestWritten, options.timeoutMs)));
     }, options.timeoutMs);
     timer.unref();
     if (options.signal?.aborted) {
@@ -5189,9 +5232,6 @@ function allocateProxyRequestId() {
 function isRetryableTool(name) {
   return name !== "rename" && name !== "lsp_rename";
 }
-function errorText(error) {
-  return error instanceof Error ? error.message : String(error);
-}
 var OMO_LSP_DAEMON_CLI2 = "OMO_LSP_DAEMON_CLI";
 var OMO_LSP_DAEMON_VERSION2 = "OMO_LSP_DAEMON_VERSION";
 var DAEMON_VERSION_PATTERN2 = /^[A-Za-z0-9][A-Za-z0-9._+-]{0,127}$/;

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