oh-my-opencode 4.18.0 → 4.18.2

package/packages/omo-codex/plugin/components/lsp/scripts/build-runtime.mjs

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+import { createHash } from "node:crypto";
+import { spawnSync } from "node:child_process";
+import { builtinModules } from "node:module";
+import {
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	readdirSync,
+	renameSync,
+	rmSync,
+	statSync,
+	writeFileSync,
+} from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const SCHEMA_VERSION = 1;
+const componentRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+const distDir = join(componentRoot, "dist");
+const manifestPath = join(distDir, ".omo-runtime-manifest.json");
+const builtinSpecifiers = new Set([
+	...builtinModules,
+	...builtinModules.map((name) => `node:${name}`),
+]);
+
+if (!existsSync(join(componentRoot, "src"))) {
+	validateDistOnlyManifest();
+	process.exit(0);
+}
+
+if (isManifestFresh()) {
+	process.exit(0);
+}
+
+rmSync(distDir, { recursive: true, force: true });
+mkdirSync(distDir, { recursive: true });
+run("tsc", ["-p", "tsconfig.build.json"]);
+run("bun", [
+	"build",
+	"src/cli.ts",
+	"--target",
+	"node",
+	"--format",
+	"esm",
+	"--outfile",
+	"dist/cli.js",
+]);
+assertBuiltinOnlyCli();
+writeManifest();
+validateManifest({ requireFreshInputs: true });
+
+function run(command, args) {
+	const result = spawnSync(command, args, {
+		cwd: componentRoot,
+		shell: process.platform === "win32",
+		stdio: "inherit",
+	});
+	if (result.error !== undefined) throw result.error;
+	if (result.status !== 0) process.exit(result.status ?? 1);
+}
+
+function isManifestFresh() {
+	try {
+		validateManifest({ requireFreshInputs: true });
+		return true;
+	} catch (error) {
+		if (error instanceof Error) return false;
+		throw error;
+	}
+}
+
+function validateDistOnlyManifest() {
+	try {
+		validateManifest({ requireFreshInputs: false });
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		console.error(`Invalid installed codex-lsp runtime manifest: ${message}`);
+		process.exit(1);
+	}
+}
+
+function validateManifest({ requireFreshInputs }) {
+	const manifest = readManifest();
+	if (manifest.schemaVersion !== SCHEMA_VERSION) throw new Error("unsupported manifest schemaVersion");
+	if (manifest.version !== packageVersion()) throw new Error("manifest version is stale");
+	if (requireFreshInputs && manifest.inputDigest !== inputDigest()) throw new Error("manifest inputDigest is stale");
+	const outputs = [...manifest.outputs].sort((left, right) => left.path.localeCompare(right.path));
+	if (JSON.stringify(outputs) !== JSON.stringify(manifest.outputs)) throw new Error("manifest outputs are not sorted");
+	for (const output of outputs) {
+		const outputPath = join(distDir, output.path);
+		if (!existsSync(outputPath)) throw new Error(`manifest output is missing: ${output.path}`);
+		if (sha256File(outputPath) !== output.sha256) throw new Error(`manifest output hash mismatch: ${output.path}`);
+	}
+}
+
+function readManifest() {
+	if (!existsSync(manifestPath)) throw new Error("manifest is missing");
+	const parsed = JSON.parse(readFileSync(manifestPath, "utf8"));
+	if (!isRecord(parsed)) throw new Error("manifest must be an object");
+	if (parsed.schemaVersion !== SCHEMA_VERSION) throw new Error("manifest schemaVersion must be 1");
+	if (typeof parsed.version !== "string") throw new Error("manifest version must be a string");
+	if (typeof parsed.inputDigest !== "string" || !/^sha256:[0-9a-f]{64}$/.test(parsed.inputDigest)) {
+		throw new Error("manifest inputDigest must be sha256:<64hex>");
+	}
+	if (!Array.isArray(parsed.outputs) || !parsed.outputs.every(isManifestOutput)) {
+		throw new Error("manifest outputs are malformed");
+	}
+	return parsed;
+}
+
+function isManifestOutput(value) {
+	return (
+		isRecord(value) &&
+		typeof value.path === "string" &&
+		value.path.length > 0 &&
+		!value.path.includes("..") &&
+		typeof value.sha256 === "string" &&
+		/^[0-9a-f]{64}$/.test(value.sha256)
+	);
+}
+
+function writeManifest() {
+	const manifest = {
+		schemaVersion: SCHEMA_VERSION,
+		version: packageVersion(),
+		inputDigest: inputDigest(),
+		outputs: outputFiles().map((path) => ({ path, sha256: sha256File(join(distDir, path)) })),
+	};
+	manifest.outputs.sort((left, right) => left.path.localeCompare(right.path));
+	const tempPath = join(distDir, `.omo-runtime-manifest.${process.pid}.tmp`);
+	writeFileSync(tempPath, `${JSON.stringify(manifest, null, 2)}\n`);
+	renameSync(tempPath, manifestPath);
+}
+
+function inputDigest() {
+	const hash = createHash("sha256");
+	for (const path of inputFiles()) {
+		hash.update(path);
+		hash.update("\0");
+		hash.update(sha256File(join(componentRoot, path)));
+		hash.update("\0");
+	}
+	return `sha256:${hash.digest("hex")}`;
+}
+
+function inputFiles() {
+	return [
+		"package.json",
+		"tsconfig.json",
+		"tsconfig.build.json",
+		"scripts/build-runtime.mjs",
+		...walk(join(componentRoot, "src")).map((path) => relative(componentRoot, path)),
+	].sort();
+}
+
+function outputFiles() {
+	return walk(distDir)
+		.map((path) => relative(distDir, path))
+		.filter((path) => path !== ".omo-runtime-manifest.json")
+		.sort();
+}
+
+function walk(root) {
+	const entries = [];
+	for (const entry of readdirSync(root, { withFileTypes: true })) {
+		const path = join(root, entry.name);
+		if (entry.isDirectory()) {
+			entries.push(...walk(path));
+		} else if (entry.isFile()) {
+			entries.push(path);
+		}
+	}
+	return entries;
+}
+
+function assertBuiltinOnlyCli() {
+	const source = readFileSync(join(distDir, "cli.js"), "utf8");
+	const specifiers = [
+		...source.matchAll(/\bimport\s+(?:[^'";]+?\s+from\s+)?["']([^"']+)["']/g),
+		...source.matchAll(/\bimport\s*\(\s*["']([^"']+)["']\s*\)/g),
+	].map((match) => match[1]);
+	const invalid = specifiers.filter((specifier) => !builtinSpecifiers.has(specifier));
+	if (invalid.length > 0) {
+		throw new Error(`dist/cli.js has non-builtin runtime imports: ${invalid.join(", ")}`);
+	}
+}
+
+function packageVersion() {
+	const parsed = JSON.parse(readFileSync(join(componentRoot, "package.json"), "utf8"));
+	if (!isRecord(parsed) || typeof parsed.version !== "string") throw new Error("package.json version is missing");
+	return parsed.version;
+}
+
+function sha256File(path) {
+	return createHash("sha256").update(readFileSync(path)).digest("hex");
+}
+
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/packages/omo-codex/plugin/components/lsp/scripts/build-runtime.test.mjs

@@ -0,0 +1,55 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { copyFile, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+const SCRIPT_URL = new URL("./build-runtime.mjs", import.meta.url);
+
+test("#given a built component runtime #when the manifest is inspected #then it pins sorted output hashes", async () => {
+	const manifest = JSON.parse(await readFile(new URL("../dist/.omo-runtime-manifest.json", import.meta.url), "utf8"));
+	assert.equal(manifest.schemaVersion, 1);
+	assert.match(manifest.inputDigest, /^sha256:[0-9a-f]{64}$/u);
+	assert.deepEqual(
+		manifest.outputs.map((output) => output.path),
+		[...manifest.outputs.map((output) => output.path)].sort(),
+	);
+	assert(manifest.outputs.some((output) => output.path === "cli.js"));
+	assert(manifest.outputs.every((output) => /^[0-9a-f]{64}$/u.test(output.sha256)));
+});
+
+test("#given a dist-only installed component #when output bytes are tampered #then validation fails actionably", async () => {
+	const root = await mkdtemp(join(tmpdir(), "codex-lsp-dist-only-"));
+	try {
+		const componentRoot = join(root, "component");
+		await mkdir(join(componentRoot, "scripts"), { recursive: true });
+		await copyFile(SCRIPT_URL, join(componentRoot, "scripts", "build-runtime.mjs"));
+		await writeFile(join(componentRoot, "package.json"), JSON.stringify({ version: "4.17.0" }));
+		await mkdir(join(componentRoot, "dist"), { recursive: true });
+		await writeFile(join(componentRoot, "dist", "cli.js"), "console.log('tampered')\n");
+		await writeFile(
+			join(componentRoot, "dist", ".omo-runtime-manifest.json"),
+			JSON.stringify(
+				{
+					schemaVersion: 1,
+					version: "4.17.0",
+					inputDigest: `sha256:${"0".repeat(64)}`,
+					outputs: [{ path: "cli.js", sha256: "1".repeat(64) }],
+				},
+				null,
+				2,
+			),
+		);
+
+		const result = spawnSync(process.execPath, [join(componentRoot, "scripts", "build-runtime.mjs")], {
+			encoding: "utf8",
+		});
+
+		assert.notEqual(result.status, 0);
+		assert.match(result.stderr, /Invalid installed codex-lsp runtime manifest/u);
+		assert.match(result.stderr, /hash mismatch/u);
+	} finally {
+		await rm(root, { recursive: true, force: true });
+	}
+});

package/packages/omo-codex/plugin/components/lsp/src/codex-hook-cli.ts

@@ -1,7 +1,5 @@
 import { stdin as processStdin } from "node:process";
 
-import { disposeDefaultLspManager } from "@code-yeongyu/lsp-daemon";
-
 import { isRecord, runLspPostCompactHook, runLspPostToolUseHook } from "./codex-hook.js";
 
 export async function runPostToolUseHookCli(stdin: NodeJS.ReadStream = processStdin): Promise<void> {
@@ -26,8 +24,6 @@ async function runHookCli(
 	} catch {
 		// LSP feedback is best-effort: stderr or a non-zero exit here surfaces as harness noise on every edit.
 		return;
-	} finally {
-		await disposeDefaultLspManager().catch(() => undefined);
 	}
 }
 

package/packages/omo-codex/plugin/components/lsp/src/codex-hook.ts

@@ -1,21 +1,24 @@
-import { readFileSync } from "node:fs";
+import { readFileSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
 
-import { callDiagnosticsViaDaemon, currentRequestContext } from "@code-yeongyu/lsp-daemon";
+import { callDiagnosticsViaDaemon } from "@code-yeongyu/lsp-daemon/client";
+import { collectPostEditDiagnostics, type PostEditDiagnosticsOutcome } from "@oh-my-opencode/lsp-core/post-edit";
+import { parseLspRequestContext, type LspRequestContext } from "@oh-my-opencode/lsp-core/request-context";
 
 import { ensureLspDaemonCliEnv } from "./daemon-cli-path.js";
 import {
 	isLspDaemonUnreachableDiagnostics,
-	isUnavailableLspDiagnostics,
 	markLspSessionCompacted,
-	recordLspDiagnosticsObservations,
+	readLspPostEditCache,
 	sessionIdFrom,
-	shouldSkipUnavailableLspDiagnostics,
+	writeLspPostEditCache,
 } from "./lsp-session-state.js";
 import { extractMutatedFilePaths } from "./mutated-file-paths.js";
 
 export { extractMutatedFilePaths } from "./mutated-file-paths.js";
 
-export type DiagnosticsRunner = (filePath: string) => Promise<string>;
+export type DiagnosticsRunner = (filePath: string) => Promise<PostEditDiagnosticsOutcome>;
 
 export interface CodexPostToolUseInput {
 	session_id?: unknown;
@@ -43,13 +46,10 @@ interface PostToolUseHookOutput {
 	};
 }
 
-const CLEAN_DIAGNOSTICS_TEXT = "No diagnostics found";
-const UNSUPPORTED_EXTENSION_TEXT = "No LSP server configured for extension:";
 const DIAGNOSTIC_START_PATTERN = /(?:error|warning|information|hint)\[[^\]\r\n]+\] \(\d+\) at \d+:\d+:/g;
 const DIAGNOSTIC_CHUNK_PATTERN = /^(?:error|warning|information|hint)\[[^\]\r\n]+\] \(\d+\) at \d+:\d+:/;
 const DEFAULT_MAX_HOOK_FEEDBACK_CHARS = 8000;
 const CONTEXT_PRESSURE_MAX_HOOK_FEEDBACK_CHARS = 1200;
-const MAX_CONCURRENT_DIAGNOSTICS = 4;
 const CONTEXT_PRESSURE_MARKERS = [
 	"context compacted",
 	"context_length_exceeded",
@@ -60,35 +60,57 @@ const CONTEXT_PRESSURE_MARKERS = [
 	"long threads and multiple compactions",
 ] as const;
 
-export async function runLspDiagnosticsText(filePath: string): Promise<string> {
+export async function runLspDiagnosticsText(filePath: string): Promise<PostEditDiagnosticsOutcome> {
 	ensureLspDaemonCliEnv();
-	const result = await callDiagnosticsViaDaemon(filePath, { context: currentRequestContext() });
+	const result = await callDiagnosticsViaDaemon(filePath, { context: codexLspRequestContext() });
+	return postEditOutcomeFromDaemonResult(result);
+}
+
+function postEditOutcomeFromDaemonResult(result: {
+	readonly content: readonly { readonly type: string; readonly text?: string }[];
+	readonly details?: unknown;
+}): PostEditDiagnosticsOutcome {
+	const availability = notConfiguredAvailability(result.details);
+	if (availability !== undefined) return { kind: "not_configured", extension: availability.extension };
 	return result.content.map((block) => block.text).join("\n");
 }
 
+function notConfiguredAvailability(details: unknown): { readonly extension: string } | undefined {
+	if (!isRecord(details)) return undefined;
+	const availability = details["availability"];
+	if (!isRecord(availability)) return undefined;
+	if (availability["kind"] !== "not_configured") return undefined;
+	const extension = availability["extension"];
+	return typeof extension === "string" && extension.length > 0 ? { extension } : undefined;
+}
+
+export function codexLspRequestContext(
+	env: Record<string, string | undefined> = process.env,
+	cwd: string = process.cwd(),
+): LspRequestContext {
+	const canonicalCwd = realpathSync(resolve(cwd));
+	const codexHome = resolve(env["CODEX_HOME"]?.trim() || join(homedir(), ".codex"));
+	return parseLspRequestContext({
+		cwd: canonicalCwd,
+		projectConfigPaths: [join(canonicalCwd, ".codex", "lsp-client.json")],
+		userConfigPath: join(codexHome, "lsp-client.json"),
+		installDecisionsPath: join(codexHome, "lsp-install-decisions.json"),
+		capabilities: { installDecisionTool: true },
+	});
+}
+
 export async function runLspPostToolUseHook(
 	input: CodexPostToolUseInput,
 	runDiagnostics: DiagnosticsRunner = runLspDiagnosticsText,
 ): Promise<string> {
 	const sessionId = sessionIdFrom(input);
-	const filePaths = extractMutatedFilePaths(input).filter(
-		(filePath) => !shouldSkipUnavailableLspDiagnostics(filePath, sessionId),
-	);
+	const filePaths = extractMutatedFilePaths(input);
 	if (filePaths.length === 0) return "";
 
-	const blocks: DiagnosticBlock[] = [];
-	const observations: Array<{ filePath: string; unavailable: boolean }> = [];
-	for (const { filePath, diagnostics } of await collectDiagnostics(filePaths, runDiagnostics)) {
-		// A daemon outage is transient (connect-or-spawn retries on the next request);
-		// recording it would silence this extension for the rest of the session.
-		if (isLspDaemonUnreachableDiagnostics(diagnostics)) continue;
-		const unavailable = isUnavailableLspDiagnostics(diagnostics);
-		observations.push({ filePath, unavailable });
-		if (isCleanDiagnostics(diagnostics)) continue;
-		if (unavailable) continue;
-		blocks.push({ filePath, diagnostics });
-	}
-	recordLspDiagnosticsObservations(sessionId, observations);
+	const cache = readLspPostEditCache(sessionId);
+	const result = await collectPostEditDiagnostics({ filePaths, runDiagnostics, cache });
+	writeLspPostEditCache(sessionId, cache);
+	const blocks = result.blocks.filter(({ diagnostics }) => !isLspDaemonUnreachableDiagnostics(diagnostics));
 
 	if (blocks.length === 0) return "";
 
@@ -110,42 +132,6 @@ export async function runLspPostCompactHook(input: CodexPostCompactInput): Promi
 	return "";
 }
 
-async function collectDiagnostics(
-	filePaths: readonly string[],
-	runDiagnostics: DiagnosticsRunner,
-): Promise<DiagnosticBlock[]> {
-	const results: DiagnosticBlock[] = [];
-	let nextIndex = 0;
-	const workerCount = Math.min(MAX_CONCURRENT_DIAGNOSTICS, filePaths.length);
-	async function worker(): Promise<void> {
-		for (;;) {
-			const index = nextIndex;
-			nextIndex += 1;
-			const filePath = filePaths[index];
-			if (filePath === undefined) return;
-			results[index] = { filePath, diagnostics: await collectFileDiagnostics(filePath, runDiagnostics) };
-		}
-	}
-	await Promise.all(Array.from({ length: workerCount }, () => worker()));
-	return results;
-}
-
-async function collectFileDiagnostics(filePath: string, runDiagnostics: DiagnosticsRunner): Promise<string> {
-	try {
-		return (await runDiagnostics(filePath)).trim();
-	} catch (error) {
-		return formatDiagnosticsError(error);
-	}
-}
-
-function formatDiagnosticsError(error: unknown): string {
-	if (error instanceof Error) {
-		const message = error.message.trim();
-		if (message.length > 0) return message;
-	}
-	return String(error).trim();
-}
-
 function formatDiagnosticBlock({ filePath, diagnostics }: DiagnosticBlock): string {
 	return `LSP diagnostics after editing ${filePath}:\n\n${formatDiagnosticsForDisplay(diagnostics)}`;
 }
@@ -221,14 +207,6 @@ function limitHookText(text: string, maxChars: number): string {
 	return `${head}${marker}`;
 }
 
-function isCleanDiagnostics(diagnostics: string): boolean {
-	return (
-		diagnostics.length === 0 ||
-		diagnostics === CLEAN_DIAGNOSTICS_TEXT ||
-		diagnostics.startsWith(UNSUPPORTED_EXTENSION_TEXT)
-	);
-}
-
 export function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/packages/omo-codex/plugin/components/lsp/src/daemon-cli-path.ts

@@ -3,28 +3,32 @@ import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
+import {
+	OMO_LSP_DAEMON_CLI,
+	OMO_LSP_DAEMON_VERSION,
+	resolveDaemonRuntime,
+} from "@code-yeongyu/lsp-daemon/client";
+
 const requireFromHere = createRequire(import.meta.url);
 
-const PACKAGE_LSP_DAEMON_CLI = "@code-yeongyu/lsp-daemon/dist/cli.js";
-const CODEX_LSP_DAEMON_CLI_ENV = "CODEX_LSP_DAEMON_CLI";
-const CODEX_LSP_DAEMON_VERSION_ENV = "CODEX_LSP_DAEMON_VERSION";
+const PACKAGE_LSP_DAEMON_CLI = "@code-yeongyu/lsp-daemon/cli";
 
 interface LspDaemonCliResolution {
 	cliPath: string;
-	version: string | null;
+	version: string;
 }
 
 export function ensureLspDaemonCliEnv(env: NodeJS.ProcessEnv = process.env): void {
-	const configuredCli = env[CODEX_LSP_DAEMON_CLI_ENV]?.trim();
-	const resolution = configuredCli ? resolveConfiguredLspDaemonCli(configuredCli) : resolveLspDaemonCli();
-	if (!configuredCli) env[CODEX_LSP_DAEMON_CLI_ENV] = resolution.cliPath;
-	if (!env[CODEX_LSP_DAEMON_VERSION_ENV]?.trim() && resolution.version !== null) {
-		env[CODEX_LSP_DAEMON_VERSION_ENV] = resolution.version;
-	}
+	const runtime = resolveDaemonRuntime(env, resolveLspDaemonCli());
+	env[OMO_LSP_DAEMON_CLI] = runtime.cliPath;
+	env[OMO_LSP_DAEMON_VERSION] = runtime.version;
 }
 
-export function resolveLspDaemonCliPath(): string {
-	return resolveLspDaemonCli().cliPath;
+export function resolveLspDaemonCliPath(env: NodeJS.ProcessEnv = process.env): string {
+	const runtime = resolveDaemonRuntime(env, resolveLspDaemonCli());
+	if (env[OMO_LSP_DAEMON_CLI] === undefined) env[OMO_LSP_DAEMON_CLI] = runtime.cliPath;
+	if (env[OMO_LSP_DAEMON_VERSION] === undefined) env[OMO_LSP_DAEMON_VERSION] = runtime.version;
+	return runtime.cliPath;
 }
 
 function resolveLspDaemonCli(): LspDaemonCliResolution {
@@ -38,15 +42,20 @@ function resolveLspDaemonCli(): LspDaemonCliResolution {
 function resolvePackageLspDaemonCliPath(): string | null {
 	try {
 		return requireFromHere.resolve(PACKAGE_LSP_DAEMON_CLI);
-	} catch {
+	} catch (error) {
+		if (!(error instanceof Error)) throw error;
 		return null;
 	}
 }
 
 function resolveConfiguredLspDaemonCli(cliPath: string): LspDaemonCliResolution {
+	const version = readDaemonPackageVersion(cliPath);
+	if (version === null) {
+		throw new Error(`Unable to determine packaged LSP daemon version beside ${cliPath}`);
+	}
 	return {
 		cliPath,
-		version: readDaemonPackageVersion(cliPath),
+		version,
 	};
 }
 
@@ -56,7 +65,9 @@ function readDaemonPackageVersion(cliPath: string): string | null {
 		if (isRecord(parsed) && typeof parsed["version"] === "string" && parsed["version"].length > 0) {
 			return parsed["version"];
 		}
-	} catch {}
+	} catch (error) {
+		if (!(error instanceof Error)) throw error;
+	}
 	return null;
 }
 

package/packages/omo-codex/plugin/components/lsp/src/lsp-session-state.ts

@@ -1,71 +1,33 @@
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, extname, join } from "node:path";
+import { dirname, join } from "node:path";
 
-interface LspSessionState {
-	readonly unavailableExtensions: readonly string[];
-	readonly postCompactProbePending?: boolean;
-}
+import type { PostEditNotConfiguredCache } from "@oh-my-opencode/lsp-core/post-edit";
 
-export interface DiagnosticsObservation {
-	readonly filePath: string;
-	readonly unavailable: boolean;
+interface LspSessionState {
+	readonly notConfiguredExtensions: readonly string[];
 }
 
 export function sessionIdFrom(input: { readonly session_id?: unknown }): string | undefined {
 	return typeof input.session_id === "string" && input.session_id.length > 0 ? input.session_id : undefined;
 }
 
-export function shouldSkipUnavailableLspDiagnostics(filePath: string, sessionId: string | undefined): boolean {
-	if (sessionId === undefined) return false;
+export function readLspPostEditCache(sessionId: string | undefined): PostEditNotConfiguredCache {
+	if (sessionId === undefined) return { notConfiguredExtensions: new Set() };
 	const state = readSessionState(sessionStatePath(sessionId));
-	const extension = extensionKey(filePath);
-	return (
-		extension !== undefined &&
-		state.postCompactProbePending !== true &&
-		state.unavailableExtensions.includes(extension)
-	);
-}
-
-export function recordLspDiagnosticsObservations(
-	sessionId: string | undefined,
-	observations: readonly DiagnosticsObservation[],
-): void {
-	if (sessionId === undefined || observations.length === 0) return;
-	const state = readSessionState(sessionStatePath(sessionId));
-	const unavailableExtensions = new Set(state.unavailableExtensions);
-
-	for (const observation of observations) {
-		const extension = extensionKey(observation.filePath);
-		if (extension === undefined) continue;
-		if (observation.unavailable) {
-			unavailableExtensions.add(extension);
-		} else {
-			unavailableExtensions.delete(extension);
-		}
-	}
-
-	writeSessionState(sessionStatePath(sessionId), { unavailableExtensions: [...unavailableExtensions].sort() });
+	return { notConfiguredExtensions: new Set(state.notConfiguredExtensions) };
 }
 
-export function markLspSessionCompacted(sessionId: string | undefined): void {
+export function writeLspPostEditCache(sessionId: string | undefined, cache: PostEditNotConfiguredCache): void {
 	if (sessionId === undefined) return;
-	const state = readSessionState(sessionStatePath(sessionId));
-	if (state.unavailableExtensions.length === 0) return;
 	writeSessionState(sessionStatePath(sessionId), {
-		unavailableExtensions: state.unavailableExtensions,
-		postCompactProbePending: true,
+		notConfiguredExtensions: [...cache.notConfiguredExtensions].sort(),
 	});
 }
 
-export function isUnavailableLspDiagnostics(diagnostics: string): boolean {
-	const normalized = diagnostics.trim();
-	return (
-		normalized.includes("LSP request timeout (method: initialize)") ||
-		normalized.includes("LSP server is still initializing") ||
-		normalized.includes("NOT INSTALLED") ||
-		normalized.includes("Command not found:")
-	);
+export function markLspSessionCompacted(sessionId: string | undefined): void {
+	if (sessionId === undefined) return;
+	writeSessionState(sessionStatePath(sessionId), emptyState());
 }
 
 export function isLspDaemonUnreachableDiagnostics(diagnostics: string): boolean {
@@ -80,7 +42,7 @@ function sessionStatePath(sessionId: string): string {
 function readSessionState(path: string): LspSessionState {
 	try {
 		const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
-		if (isLspSessionState(parsed)) return parsed;
+		if (isRecord(parsed) && isLspSessionState(parsed)) return normalizeSessionState(parsed);
 		return emptyState();
 	} catch (error) {
 		if (error instanceof SyntaxError || (isRecord(error) && error["code"] === "ENOENT")) return emptyState();
@@ -94,25 +56,25 @@ function writeSessionState(path: string, state: LspSessionState): void {
 }
 
 function emptyState(): LspSessionState {
-	return { unavailableExtensions: [] };
-}
-
-function extensionKey(filePath: string): string | undefined {
-	const extension = extname(filePath).toLowerCase();
-	return extension.length === 0 ? undefined : extension;
+	return { notConfiguredExtensions: [] };
 }
 
 function safePathSegment(value: string): string {
 	return value.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 120) || "unknown-session";
 }
 
-function isLspSessionState(value: unknown): value is LspSessionState {
-	if (!isRecord(value) || !Array.isArray(value["unavailableExtensions"])) return false;
-	const postCompactProbePending = value["postCompactProbePending"];
-	return (
-		value["unavailableExtensions"].every((item) => typeof item === "string") &&
-		(postCompactProbePending === undefined || typeof postCompactProbePending === "boolean")
-	);
+function isLspSessionState(value: Record<string, unknown>): boolean {
+	const notConfiguredExtensions = value["notConfiguredExtensions"] ?? value["unavailableExtensions"];
+	return Array.isArray(notConfiguredExtensions) && notConfiguredExtensions.every((item) => typeof item === "string");
+}
+
+function normalizeSessionState(value: Record<string, unknown>): LspSessionState {
+	const notConfiguredExtensions = value["notConfiguredExtensions"] ?? value["unavailableExtensions"];
+	return {
+		notConfiguredExtensions: Array.isArray(notConfiguredExtensions)
+			? notConfiguredExtensions.filter((item) => typeof item === "string").sort()
+			: [],
+	};
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {