lazycodex-ai 5.0.0-beta.6 → 5.0.0-beta.60

package/packages/omo-codex/plugin/components/lazycodex-executor-verify/src/codex-hook.ts

@@ -3,20 +3,19 @@ import { isAbsolute, relative, resolve } from "node:path";
 
 import { renderDirective } from "./directive.js";
 import { clearAttemptState, MAX_ATTEMPTS, readAttemptState, writeAttemptState } from "./state.js";
-import type { HookFileSystem, StopHookOutput, SubagentStopInput } from "./types.js";
+import type { FileStat, HookFileSystem, StopHookOutput, SubagentStopInput } from "./types.js";
 import { SUBAGENT_STOP_EVENT } from "./types.js";
 
-const RECEIPT_ENFORCED_AGENTS = new Set([
-	"lazycodex-worker-low",
-	"lazycodex-worker-medium",
-	"lazycodex-worker-high",
-]);
+const RECEIPT_ENFORCED_AGENTS = new Set(["lazycodex-worker-low", "lazycodex-worker-medium", "lazycodex-worker-high"]);
+
+type EvidenceReceiptFailure = "invalid" | "placeholder" | "stale" | null;
 
 export function runSubagentStopHook(input: unknown, fs: HookFileSystem): string {
 	if (!isSubagentStopInput(input)) return "";
 	if (!RECEIPT_ENFORCED_AGENTS.has(input.agent_type)) return "";
 	if (transcriptHasContextPressureMarker(input.transcript_path, fs)) return "";
-	if (hasValidEvidenceReceipt(input, fs)) {
+	const receiptFailure = getEvidenceReceiptFailure(input, fs);
+	if (receiptFailure === null) {
 		clearAttemptState(input.cwd, input.session_id, input.agent_id, fs);
 		return "";
 	}
@@ -29,7 +28,7 @@ export function runSubagentStopHook(input: unknown, fs: HookFileSystem): string
 	writeAttemptState(input.cwd, input.session_id, input.agent_id, { attempts }, fs);
 	return JSON.stringify({
 		decision: "block",
-		reason: renderDirective(attempts, input.last_assistant_message),
+		reason: `Evidence receipt rejected: ${receiptFailure}.\n\n${renderDirective(attempts, input.last_assistant_message)}`,
 	} satisfies StopHookOutput);
 }
 
@@ -53,16 +52,16 @@ function transcriptHasContextPressureMarker(transcriptPath: string, fs: HookFile
 	}
 }
 
-function hasValidEvidenceReceipt(input: SubagentStopInput, fs: HookFileSystem): boolean {
+function getEvidenceReceiptFailure(input: SubagentStopInput, fs: HookFileSystem): EvidenceReceiptFailure {
 	const receiptPath = extractEvidencePath(input.last_assistant_message);
-	if (receiptPath === null) return false;
+	if (receiptPath === null) return "invalid";
 	const evidenceRoot = resolve(input.cwd, ".omo", "evidence");
 	const resolvedPath = isAbsolute(receiptPath) ? resolve(receiptPath) : resolve(input.cwd, receiptPath);
-	if (!isPathInsideDirectory(resolvedPath, evidenceRoot)) return false;
+	if (!isPathInsideDirectory(resolvedPath, evidenceRoot)) return "invalid";
 	try {
-		return isNonEmptyFileInsideEvidenceRoot(resolvedPath, evidenceRoot, input.cwd, fs);
+		return getEvidenceFileFailure(resolvedPath, evidenceRoot, input, fs);
 	} catch (error) {
-		if (error instanceof Error) return false;
+		if (error instanceof Error) return "invalid";
 		throw error;
 	}
 }
@@ -72,28 +71,33 @@ function isPathInsideDirectory(filePath: string, directoryPath: string): boolean
 	return relativePath !== "" && !relativePath.startsWith("..") && !isAbsolute(relativePath);
 }
 
-function isNonEmptyFileInsideEvidenceRoot(
+function getEvidenceFileFailure(
 	filePath: string,
 	evidenceRoot: string,
-	cwd: string,
+	input: SubagentStopInput,
 	fs: HookFileSystem,
-): boolean {
-	if (!fs.existsSync(filePath)) return false;
-	const realCwd = realPath(cwd, fs);
+): EvidenceReceiptFailure {
+	if (!fs.existsSync(filePath)) return "invalid";
+	const realCwd = realPath(input.cwd, fs);
 	const realEvidenceRoot = realPath(evidenceRoot, fs);
 	const realFilePath = realPath(filePath, fs);
-	if (!isPathInsideDirectory(realEvidenceRoot, realCwd)) return false;
-	if (!isPathInsideDirectory(realFilePath, realEvidenceRoot)) return false;
-	return isNonEmptyFile(filePath, fs);
-}
-
-function isNonEmptyFile(filePath: string, fs: HookFileSystem): boolean {
-	if (!fs.existsSync(filePath)) return false;
+	if (!isPathInsideDirectory(realEvidenceRoot, realCwd)) return "invalid";
+	if (!isPathInsideDirectory(realFilePath, realEvidenceRoot)) return "invalid";
 	const linkStat = fs.lstatSync?.(filePath) ?? nodeLstatSync(filePath);
-	if (linkStat.isSymbolicLink?.() === true) return false;
+	if (linkStat.isSymbolicLink?.() === true) return "invalid";
 	const stat = fs.statSync(filePath);
-	if (stat.size <= 0) return false;
-	return stat.isFile?.() ?? true;
+	if (stat.isFile?.() === false) return "invalid";
+	if (stat.size <= 0 || fs.readFileSync(filePath, "utf8").trim().length < 40) return "placeholder";
+	let transcriptStat: FileStat;
+	try {
+		transcriptStat = fs.statSync(input.transcript_path);
+	} catch (error) {
+		if (error instanceof Error) return null;
+		throw error;
+	}
+	const transcriptStart = transcriptStat.birthtimeMs ?? transcriptStat.ctimeMs;
+	if (transcriptStart !== undefined && (stat.mtimeMs === undefined || stat.mtimeMs < transcriptStart)) return "stale";
+	return null;
 }
 
 function realPath(path: string, fs: HookFileSystem): string {

package/packages/omo-codex/plugin/components/lazycodex-executor-verify/src/types.ts

@@ -21,6 +21,9 @@ export type StopHookOutput = {
 
 export type FileStat = {
 	readonly size: number;
+	readonly mtimeMs?: number;
+	readonly birthtimeMs?: number;
+	readonly ctimeMs?: number;
 	readonly isFile?: () => boolean;
 	readonly isSymbolicLink?: () => boolean;
 };

package/packages/omo-codex/plugin/components/lazycodex-executor-verify/test/cli.test.ts

@@ -59,7 +59,7 @@ describe("lazycodex executor verify CLI", () => {
 		const cwd = createWorkspace();
 		const artifactPath = join(cwd, ".omo", "evidence", "receipt.txt");
 		mkdirSync(join(cwd, ".omo", "evidence"), { recursive: true });
-		writeFileSync(artifactPath, "verified\n");
+		writeFileSync(artifactPath, "Command: verify\nExit code: 0\nOutput: all checks passed.\n");
 		const payload = JSON.stringify(
 			createPayload(cwd, { last_assistant_message: `EVIDENCE_RECORDED: ${artifactPath}` }),
 		);

package/packages/omo-codex/plugin/components/lazycodex-executor-verify/test/codex-hook.test.ts

@@ -12,12 +12,12 @@ import {
 	writeFileSync,
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { platform } from "node:process";
 import { afterEach, describe, expect, it } from "vitest";
 
 import { runSubagentStopHook } from "../src/codex-hook.js";
-import type { SubagentStopInput } from "../src/types.js";
+import type { FileStat, HookFileSystem, SubagentStopInput } from "../src/types.js";
 
 const cleanupRoots: string[] = [];
 
@@ -36,10 +36,8 @@ describe("lazycodex executor SubagentStop verifier", () => {
 		// then
 		const parsed = parseBlockOutput(output);
 		expect(parsed.decision).toBe("block");
-		expect(parsed.reason).toContain("너는 방금 작업을 완료했다고 보고했고, 그건 거짓말이다.");
 		expect(parsed.reason).toContain(".omo/evidence/");
 		expect(parsed.reason).toContain("EVIDENCE_RECORDED: <path>");
-		expect(parsed.reason).not.toContain("2번째");
 	});
 
 	it("#given a prior blocked stop #when lazycodex executor stops again #then escalates the attempt count", () => {
@@ -51,8 +49,9 @@ describe("lazycodex executor SubagentStop verifier", () => {
 		const output = runSubagentStopHook(createInput(cwd), nodeFileSystem);
 
 		// then
-		const parsed = parseBlockOutput(output);
-		expect(parsed.reason).toContain("2번째");
+		expect(parseBlockOutput(output).decision).toBe("block");
+		const statePath = join(cwd, ".omo", "lazycodex-executor-verify", "sess.1-agent_1.json");
+		expect(JSON.parse(readFileSync(statePath, "utf8"))).toEqual({ attempts: 2 });
 	});
 
 	it("#given turn_id is omitted #when lazycodex executor stops #then the hook still parses the payload", () => {
@@ -72,7 +71,7 @@ describe("lazycodex executor SubagentStop verifier", () => {
 		runSubagentStopHook(createInput(cwd), nodeFileSystem);
 		const artifactPath = join(cwd, ".omo", "evidence", "receipt.txt");
 		mkdirSync(join(cwd, ".omo", "evidence"), { recursive: true });
-		writeFileSync(artifactPath, "verified\n");
+		writeFileSync(artifactPath, "Command: verify\nExit code: 0\nOutput: all checks passed.\n");
 
 		// when
 		const output = runSubagentStopHook(
@@ -141,7 +140,7 @@ describe("lazycodex executor SubagentStop verifier", () => {
 		const outsideReceipt = join(outsideRoot, "receipt.txt");
 		const linkPath = join(cwd, ".omo", "evidence", "outside-dir");
 		mkdirSync(join(cwd, ".omo", "evidence"), { recursive: true });
-		writeFileSync(outsideReceipt, "outside\n");
+		writeFileSync(outsideReceipt, "outside evidence root\n".repeat(3));
 		symlinkSync(outsideRoot, linkPath, platform === "win32" ? "junction" : "dir");
 
 		// when
@@ -187,7 +186,7 @@ describe("lazycodex executor SubagentStop verifier", () => {
 		// given
 		const cwd = createWorkspace();
 		mkdirSync(join(cwd, ".omo"), { recursive: true });
-		writeFileSync(join(cwd, ".omo", "outside.txt"), "outside\n");
+		writeFileSync(join(cwd, ".omo", "outside.txt"), "outside evidence root\n".repeat(3));
 
 		// when
 		const output = runSubagentStopHook(
@@ -252,6 +251,132 @@ describe("lazycodex executor SubagentStop verifier", () => {
 	});
 });
 
+describe("receipt content and freshness", () => {
+	it.each(["placeholder evidence\n", "x".repeat(39), `  ${"x".repeat(39)}\n`])(
+		"#given a short trimmed receipt %j #when the worker stops #then blocks as placeholder",
+		(content) => {
+			// given
+			const { input, fs } = createMemoryReceipt(content, { mtimeMs: 2_000 }, { birthtimeMs: 1_000 });
+
+			// when
+			const output = runSubagentStopHook(input, fs);
+
+			// then
+			expect(parseBlockOutput(output).reason).toContain("placeholder");
+		},
+	);
+
+	it("#given a 200-character receipt older than transcript birth #when the worker stops #then blocks as stale", () => {
+		// given
+		const { input, fs } = createMemoryReceipt("x".repeat(200), { mtimeMs: 999 }, { birthtimeMs: 1_000 });
+
+		// when
+		const output = runSubagentStopHook(input, fs);
+
+		// then
+		expect(parseBlockOutput(output).reason).toContain("stale");
+	});
+
+	it("#given a fresh 200-character receipt #when transcript birth precedes ctime #then passes using birthtime", () => {
+		// given
+		const { input, fs } = createMemoryReceipt(
+			"x".repeat(200),
+			{ mtimeMs: 1_001 },
+			{ birthtimeMs: 1_000, ctimeMs: 3_000 },
+		);
+
+		// when
+		const output = runSubagentStopHook(input, fs);
+
+		// then
+		expect(output).toBe("");
+	});
+
+	it("#given a 200-character receipt and unstatable transcript #when the worker stops #then skips freshness", () => {
+		// given
+		const { input, fs } = createMemoryReceipt("x".repeat(200), { mtimeMs: 0 });
+
+		// when
+		const output = runSubagentStopHook({ ...input, transcript_path: "/nonexistent" }, fs);
+
+		// then
+		expect(output).toBe("");
+	});
+
+	it("#given 40 trimmed characters with mtime equal to transcript birth #when the worker stops #then passes", () => {
+		// given
+		const { input, fs } = createMemoryReceipt(`  ${"x".repeat(40)}\n`, { mtimeMs: 1_000 }, { birthtimeMs: 1_000 });
+
+		// when
+		const output = runSubagentStopHook(input, fs);
+
+		// then
+		expect(output).toBe("");
+	});
+
+	it.each([999, 1_000])(
+		"#given no transcript birthtime and receipt mtime %i #when the worker stops #then uses ctime",
+		(mtimeMs) => {
+			// given
+			const { input, fs } = createMemoryReceipt("x".repeat(200), { mtimeMs }, { ctimeMs: 1_000 });
+
+			// when
+			const output = runSubagentStopHook(input, fs);
+
+			// then
+			if (mtimeMs < 1_000) expect(parseBlockOutput(output).reason).toContain("stale");
+			else expect(output).toBe("");
+		},
+	);
+});
+
+function createMemoryReceipt(
+	content: string,
+	receiptStat: Partial<FileStat>,
+	transcriptStat?: Partial<FileStat>,
+): { readonly input: SubagentStopInput; readonly fs: HookFileSystem } {
+	const cwd = resolve("receipt-workspace");
+	const transcriptPath = join(cwd, "transcript.jsonl");
+	const files = new Map<string, { readonly content: string; readonly stat: Partial<FileStat> }>([
+		[join(cwd, ".omo", "evidence", "receipt.txt"), { content, stat: receiptStat }],
+	]);
+	if (transcriptStat !== undefined) files.set(transcriptPath, { content: "", stat: transcriptStat });
+	const fileAt = (path: string) => {
+		const file = files.get(path);
+		if (file === undefined) throw new Error(`ENOENT: ${path}`);
+		return file;
+	};
+	const statAt = (path: string): FileStat => {
+		const file = fileAt(path);
+		return { size: file.content.length, isFile: () => true, isSymbolicLink: () => false, ...file.stat };
+	};
+	const fs: HookFileSystem = {
+		existsSync: (path) => files.has(path),
+		lstatSync: statAt,
+		mkdirSync: () => undefined,
+		readFileSync: (path) => fileAt(path).content,
+		realpathSync: (path) => resolve(path),
+		renameSync: (oldPath, newPath) => {
+			files.set(newPath, fileAt(oldPath));
+			files.delete(oldPath);
+		},
+		rmSync: (path) => {
+			files.delete(path);
+		},
+		statSync: statAt,
+		writeFileSync: (path, data) => {
+			files.set(path, { content: data, stat: {} });
+		},
+	};
+	return {
+		input: createInput(cwd, {
+			transcript_path: transcriptPath,
+			last_assistant_message: "done\nEVIDENCE_RECORDED: .omo/evidence/receipt.txt",
+		}),
+		fs,
+	};
+}
+
 type BlockOutput = {
 	readonly decision: "block";
 	readonly reason: string;
@@ -279,7 +404,7 @@ function createWorkspaceWithParentOutsideReceipt(): { readonly cwd: string } {
 	const root = createWorkspace();
 	const cwd = join(root, "project");
 	mkdirSync(cwd, { recursive: true });
-	writeFileSync(join(root, "outside.txt"), "outside\n");
+	writeFileSync(join(root, "outside.txt"), "outside evidence root\n".repeat(3));
 	return { cwd };
 }
 
@@ -292,7 +417,7 @@ function existingReceiptTargetOutsideEvidenceRoot(): string {
 	if (existsSync("/etc/passwd") && statSync("/etc/passwd").size > 0) return "/etc/passwd";
 	const root = createWorkspace();
 	const receiptPath = join(root, "outside.txt");
-	writeFileSync(receiptPath, "outside\n");
+	writeFileSync(receiptPath, "outside evidence root\n".repeat(3));
 	return receiptPath;
 }
 
@@ -375,9 +500,7 @@ describe("tier worker receipt enforcement", () => {
 
 	it("#given both hook manifests #when their matchers are applied #then enforced agents match and read-only roles do not", () => {
 		// given
-		const componentManifest = JSON.parse(
-			readFileSync(new URL("../hooks/hooks.json", import.meta.url), "utf8"),
-		);
+		const componentManifest = JSON.parse(readFileSync(new URL("../hooks/hooks.json", import.meta.url), "utf8"));
 		const rootManifest = JSON.parse(
 			readFileSync(
 				new URL("../../../hooks/subagent-stop-verifying-lazycodex-executor-evidence.json", import.meta.url),
@@ -394,18 +517,4 @@ describe("tier worker receipt enforcement", () => {
 			expect(matcher.test("lazycodex-gate-reviewer")).toBe(false);
 		}
 	});
-
-	it("#given the tier worker TOMLs #when inspected #then each instructs the EVIDENCE_RECORDED receipt line", () => {
-		for (const tier of ["low", "medium", "high"]) {
-			// when
-			const toml = readFileSync(
-				new URL(`../../ultrawork/agents/lazycodex-worker-${tier}.toml`, import.meta.url),
-				"utf8",
-			);
-
-			// then
-			expect(toml).toContain("EVIDENCE_RECORDED: <path>");
-		}
-	});
 });
-

package/packages/omo-codex/plugin/components/lcx/skills/lcx-doctor/SKILL.md

@@ -66,11 +66,12 @@ sync_latest_source openai/codex "$LAZYCODEX_SOURCE_ROOT/openai-codex-source"
    - Installed LazyCodex version: the `version` in the installed plugin manifest, discoverable with `find "${CODEX_HOME:-$HOME/.codex}/plugins" -path '*/.codex-plugin/plugin.json'`. Installed plugins live under `$CODEX_HOME/plugins/cache/<marketplace>/<name>/<version>/`.
    - Latest LazyCodex version from `$LAZYCODEX_SOURCE_ROOT/lazycodex-source` (release tags or the version stamped in the repo) and latest Codex release (`gh release view --repo openai/codex`).
    - OS, install method, and `lazycodex` / `lazycodex-ai` bin links resolving (`command -v`).
+   - Astra readiness. The LazyCodex catalog default is `gpt-6-astra`, which Codex only knows from codex-cli 0.153.1 onward. First release tag containing the `models.json` change: `rust-v0.153.1` (backport commit `5cc1c94b8e`). Reproduce on a full clone with tags: `git -C <codex-clone> log --format='%h %d' -S gpt-6-astra -- codex-rs/models-manager/models.json`, then `git -C <codex-clone> tag --contains 5cc1c94b8e | sort -V | head -1`; a shallow clone or one without tags returns nothing. Record the installed version from `codex --version`, the root `model` in `$CODEX_HOME/config.toml` (informational only, it doesn't change the verdict), and, when `$CODEX_HOME/models_cache.json` exists, whether it contains `gpt-6-astra` (`grep -c gpt-6-astra "${CODEX_HOME:-$HOME/.codex}/models_cache.json"`). Verdict: PASS when `codex --version` is 0.153.1 or newer and `models_cache.json` is either absent or lists `gpt-6-astra`. WARN when the version is older than 0.153.1, or the cache exists but lacks `gpt-6-astra`; remediation is upgrading Codex (`npm install -g @openai/codex@latest`, or the package manager that installed `codex`), then starting Codex once so `models_cache.json` refreshes.
 3. Check config and wiring against the latest installer, not against assumptions. Read what the current installer under `$LAZYCODEX_SOURCE_ROOT/lazycodex-source` writes (installer sources live in the omo-codex package, e.g. `scripts/install/`), then verify the local equivalents:
    - `$CODEX_HOME/config.toml` exists and parses; LazyCodex-managed entries match what the latest installer would write.
    - Plugin payload present and non-empty: read `.codex-plugin/plugin.json`; when that manifest declares a `hooks` array, validate every direct hook path declared by the manifest; require `hooks/hooks.json` only when the manifest declares it; do not require retired paths such as `components/workflow-selector` or `hooks/user-prompt-submit-selecting-lazycodex-workflow.json` unless the current manifest declares them.
    - Verify the manifest-declared runtime payload, not a remembered source tree. Current payload includes `skills/`, `.mcp.json`, root CLI runtimes such as `dist/cli/index.js` and `dist/cli-node/index.js`, and every hook/MCP `components/*/dist/*.js` target referenced by installed manifests.
-   - Treat install-time materialization rewrites as expected when the rewritten target exists and is non-empty. For example, `.mcp.json` may use plugin-local or absolute installed paths for CodeGraph/MCP runtimes; that is PASS/WARN context, not payload drift. Missing or zero-byte rewritten targets are FAIL.
+   - Treat install-time materialization rewrites as expected when the rewritten target exists and is non-empty. For example, `.mcp.json` may use plugin-local or absolute installed paths for MCP runtimes; that is PASS/WARN context, not payload drift. Missing or zero-byte rewritten targets are FAIL.
    - Stale project-local leftovers the installer now removes (e.g. `.codex/hooks.json`, `.codex/skills` in the project) are flagged, not deleted.
 4. Probe the real surface. Do not invoke `lazycodex doctor`; this skill is already running inside that doctor workflow, so calling it would recurse. Instead run non-recursive probes directly: `codex --version`, `command -v codex`, the bin-link checks above, config/plugin payload inspections, and a trivial non-interactive Codex invocation that loads the plugin. Use the configured Codex default model for the runtime probe unless the user explicitly passed a model override to the doctor surface; never force a guessed/rejected model such as `gpt-5.5-codex-mini`. Capture stderr verbatim; a clean exit with warnings is WARN, not PASS.
 5. Compare for drift. Where installed manifest-declared bundled files differ from the same files at the installed version, or the latest source removed or renamed something the local config still references, record it with both paths. Do not report expected materialization differences, such as absolute `.mcp.json` runtime paths, as drift when their targets exist and are non-empty.
@@ -96,6 +97,7 @@ sync_latest_source openai/codex "$LAZYCODEX_SOURCE_ROOT/openai-codex-source"
 | Check | Verdict | Evidence |
 | --- | --- | --- |
 | Versions current | PASS/WARN/FAIL | [command output or file:line] |
+| Astra readiness | PASS/WARN | [`codex --version` vs the 0.153.1 floor; `gpt-6-astra` present/absent in `$CODEX_HOME/models_cache.json`; configured root `model`] |
 | config.toml integrity | PASS/WARN/FAIL | [evidence] |
 | Plugin payload wiring | PASS/WARN/FAIL | [evidence] |
 | Bin links / aliases | PASS/WARN/FAIL | [evidence] |
@@ -103,7 +105,7 @@ sync_latest_source openai/codex "$LAZYCODEX_SOURCE_ROOT/openai-codex-source"
 | Drift vs latest source | PASS/WARN/FAIL | [evidence, citing `$LAZYCODEX_SOURCE_ROOT/lazycodex-source` or `$LAZYCODEX_SOURCE_ROOT/openai-codex-source` paths] |
 
 ### Remediations
-1. [Most important fix first: exact command or config edit, and what it resolves.]
+1. [Most important fix first: exact command or config edit, and what it resolves. When Astra readiness is WARN: upgrade Codex to 0.153.1 or newer and relaunch it once so `models_cache.json` picks up `gpt-6-astra`.]
 
 ### Known Issues Matched
 - [issue URL — or "none found"]

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

@@ -1,26 +1,41 @@
-# Repository Conventions
+# lsp — Codex LSP integration (PostToolUse diagnostics + MCP routing)
 
-Conventions for humans and agents working on this repository.
+**Generated:** 2026-08-24 (refresh pass)
 
-## Style
+## OVERVIEW
 
-- TypeScript strict mode. No `any`, `@ts-ignore`, `@ts-expect-error`, or enums.
-- ESM modules with `.js` suffix in import paths.
-- Tabs for indentation. Double quotes for strings.
-- Runtime is Node only.
-- Tests use vitest and should exercise Codex hook/MCP behavior before implementation changes.
+`@code-yeongyu/codex-lsp` (Node >=20). Codex-specific integration only: a `PostToolUse` hook (matcher `^(apply_patch|Write|Edit|MultiEdit|multi_edit|write|edit|multiedit)$`, 60s timeout) that runs error diagnostics on files mutated by edit tools and injects blocking feedback plus the same diagnostics as additional context, and a `PostCompact` hook that resets the per-session diagnostics cache. The LSP/MCP runtime lives upstream: `src/cli.ts` routes the `mcp` subcommand to the vendored repo-root `packages/lsp-tools-mcp/` + `packages/lsp-daemon/` builds (wired via the component `.mcp.json` → `../../../../lsp-daemon/dist/cli.js mcp`); this component consumes `@oh-my-opencode/lsp-core` and `@code-yeongyu/lsp-daemon/client` and stays standalone.
+
+Deletes are ignored (cannot introduce new diagnostics); unsupported extensions and clean files emit no hook output.
+
+## KEY FILES
+
+| File | Role |
+|------|------|
+| `src/cli.ts` | Entry: routes `mcp` to the upstream runtime; `hook post-tool-use` / `hook post-compact` stay local |
+| `src/codex-hook.ts` | Hook logic: request context, mutated-file extraction, daemon diagnostics call, output shaping (`runLspPostToolUseHook`, `runLspPostCompactHook`, `codexLspRequestContext`) |
+| `src/mutated-file-paths.ts` | Tool-input → file path extraction (`path`/`filePath`/`file_path` aliases, `apply_patch` command parsing) |
+| `src/lsp-session-state.ts` | Per-session post-edit cache, compaction marking, daemon-unreachable detection |
+| `src/daemon-cli-path.ts` | Resolves/vets the lsp-daemon CLI and its env (`resolveLspDaemonCliPath`, `ensureLspDaemonCliEnv`) |
+| `scripts/build-lsp-tools.mjs`, `build-lsp-daemon.mjs`, `build-runtime.mjs` | Vendored upstream builds (run by `prebuild`/`pretest` hooks) |
+| `scripts/test.mjs` | Test driver behind `npm test` |
 
-## Commands
+## COMMANDS
 
-- `npm install` installs dependencies.
-- `npm test` runs the test suite once.
-- `npm run typecheck` runs strict TypeScript checking.
-- `npm run check` runs typecheck, Biome, and build.
+- `npm install` then `npm run bootstrap` (builds vendored lsp-tools-mcp + lsp-daemon)
+- `npm test` (builds first, then `node scripts/test.mjs`); `npm run test:watch`
+- `npm run typecheck` / `npm run lint` / `npm run check` (typecheck + Biome + build)
 
 ## LSP Constraints
 
-- LSP server processes are owned by `LspManager`.
+- LSP server processes are owned by `LspManager` (upstream runtime).
 - 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.
+- `.mcp.json` sets `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.
+
+## Style
+
+- TypeScript strict mode. No `any`, `@ts-ignore`, `@ts-expect-error`, or enums.
+- ESM modules with `.js` suffix in import paths. Tabs. Double quotes.
+- Runtime is Node only; tests use vitest and should exercise Codex hook/MCP behavior before implementation changes.

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

@@ -1,9 +1,9 @@
 {
-	"$schema": "https://biomejs.dev/schemas/2.4.15/schema.json",
+	"$schema": "https://biomejs.dev/schemas/2.5.9/schema.json",
 	"linter": {
 		"enabled": true,
 		"rules": {
-			"recommended": true,
+			"preset": "recommended",
 			"style": {
 				"noDefaultExport": "error",
 				"noEnum": "error",

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

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
-  "version": "5.0.0-beta.6",
-  "inputDigest": "sha256:afdcecf148c40dc379c51029b68a596640534290cbc5fd88359c4e3c937035fd",
+  "version": "5.0.0-beta.60",
+  "inputDigest": "sha256:35c40ea27ccc412089d9bcf1e58810b6889dd51c24d269191d092bf8ed3c4c4d",
   "outputs": [
     {
       "path": "cli.d.ts",
@@ -9,7 +9,7 @@
     },
     {
       "path": "cli.js",
-      "sha256": "8b31921f00d7333877fa0ba3b50e7318096656ad92249b285148c6fada11459d"
+      "sha256": "54d3621c04697495054be69fd6328d7b9044034801b295868b23bd92d344a816"
     },
     {
       "path": "codex-hook-cli.d.ts",
@@ -33,7 +33,7 @@
     },
     {
       "path": "daemon-cli-path.js",
-      "sha256": "5c34353638e95d4a98664c8d23516475e850983e81900aa40e03752946162830"
+      "sha256": "96812ddde5100fc408c6109949f07df3df817282dae48428f01a4c3967b4795a"
     },
     {
       "path": "lsp-session-state.d.ts",