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

package/dist/skills/ultimate-browsing/references/insane-search/README.md

@@ -16,7 +16,8 @@
 1. WebFetch, 즉흥 curl, 수동 헤더 조합 **시도 금지**
 2. 즉시 다음을 실행:
    ```bash
-   python3 -m engine "<URL>" [--selector "<CSS>"] [--device auto|desktop|mobile] [--trace]
+   python3 -m engine "<URL>" [--selector "<CSS>"] [--device auto|desktop|mobile] [--trace] \
+                              [--no-retry] [--no-extract]
    ```
 3. 종료코드 0(ok) 또는 1(fail) 받은 뒤 판단. trace를 먼저 읽고 재시도 결정.
 4. 실패 시에만 `--trace --json`으로 재호출해서 원인 진단 후 `--device` 또는 `user_hint` 조정.
@@ -135,7 +136,13 @@ result = fetch(
 
 if result.ok:
     print(result.verdict)     # strong_ok | weak_ok
-    html = result.content
+    html = result.content     # raw body — 단, content-rescue가 발동한 경우 구조 텍스트
+    # v0.10.0 content-rescue: PDF 응답은 pypdf 추출 텍스트, visible text가 얇은
+    # SPA 셸은 JSON-LD articleBody / 렌더된 innerText로 대체될 수 있다.
+    # result.extraction_source로 판별: "raw"(원문 그대로) | pdf | json_ld | *+inner_text.
+    # 일반 HTML 성공은 항상 raw. 끄기: enable_extraction=False / --no-extract.
+    # 429/502/503/504는 probe에서 백오프 재시도(Retry-After 반영, 총 10초 캡);
+    # 끄기: enable_retry=False / --no-retry.
 else:
     # Phase 3 수동 개입 (Playwright MCP) 필요 — result.trace로 원인 진단
     pass

package/dist/tools/session-manager/directory-filter.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeSessionDirectory(directory: string): string;
+export declare function sessionDirectoriesMatch(stored: string, filter: string): boolean;

package/dist/tui.js

@@ -17180,11 +17180,7 @@ var init_memory = __esm(() => {
   }).strict();
   OmoMemoryRecallSchema = object({
     enabled: boolean2().default(true),
-    max_items: number2().int().min(1).max(5).default(2),
-    budget_tokens: number2().int().positive().default(600),
-    excerpt_chars: number2().int().positive().default(200),
-    min_score: number2().optional(),
-    exclude: array(string2()).default([])
+    max_items: number2().int().min(1).max(5).default(2)
   }).strict();
   OmoMemoryNudgeSchema = object({
     enabled: boolean2().default(true),
@@ -17234,11 +17230,7 @@ var init_memory = __esm(() => {
   }).strict();
   OmoMemoryRecallLayerSchema = object({
     enabled: boolean2().optional(),
-    max_items: number2().int().min(1).max(5).optional(),
-    budget_tokens: number2().int().positive().optional(),
-    excerpt_chars: number2().int().positive().optional(),
-    min_score: number2().optional(),
-    exclude: array(string2()).optional()
+    max_items: number2().int().min(1).max(5).optional()
   }).strict();
   OmoMemoryNudgeLayerSchema = object({
     enabled: boolean2().optional(),
@@ -17309,13 +17301,7 @@ var init_memory = __esm(() => {
     write_notice: OmoMemoryWriteNoticeSchema.default({ enabled: true }),
     sync: OmoMemorySyncSchema.default({ enabled: true }),
     search: OmoMemorySearchSchema.default({ enabled: true }),
-    recall: OmoMemoryRecallSchema.default({
-      enabled: true,
-      max_items: 2,
-      budget_tokens: 600,
-      excerpt_chars: 200,
-      exclude: []
-    }),
+    recall: OmoMemoryRecallSchema.default({ enabled: true, max_items: 2 }),
     compile_warn_tokens: number2().int().positive().default(30000),
     agents: record(string2(), OmoMemoryAgentOverridesSchema).default({})
   }).strict();
@@ -20048,6 +20034,111 @@ var init_supplemental_entries = __esm(() => {
         input: 272000,
         output: 128000
       }
+    },
+    "grok-4.5": {
+      id: "grok-4.5",
+      family: "grok",
+      reasoning: false,
+      temperature: true,
+      toolCall: true,
+      modalities: {
+        input: ["text", "image"],
+        output: ["text"]
+      },
+      limit: {
+        context: 500000,
+        output: 32768
+      }
+    },
+    "xai/grok-4.5": {
+      id: "xai/grok-4.5",
+      family: "grok",
+      reasoning: false,
+      temperature: true,
+      toolCall: true,
+      modalities: {
+        input: ["text", "image"],
+        output: ["text"]
+      },
+      limit: {
+        context: 500000,
+        output: 32768
+      }
+    },
+    "x-ai/grok-4.5": {
+      id: "x-ai/grok-4.5",
+      family: "grok",
+      reasoning: false,
+      temperature: true,
+      toolCall: true,
+      modalities: {
+        input: ["text", "image"],
+        output: ["text"]
+      },
+      limit: {
+        context: 500000,
+        output: 32768
+      }
+    },
+    "grok-4.6": {
+      id: "grok-4.6",
+      family: "grok",
+      reasoning: false,
+      temperature: true,
+      toolCall: true,
+      modalities: {
+        input: ["text", "image"],
+        output: ["text"]
+      },
+      limit: {
+        context: 500000,
+        output: 32768
+      }
+    },
+    "xai/grok-4.6": {
+      id: "xai/grok-4.6",
+      family: "grok",
+      reasoning: false,
+      temperature: true,
+      toolCall: true,
+      modalities: {
+        input: ["text", "image"],
+        output: ["text"]
+      },
+      limit: {
+        context: 500000,
+        output: 32768
+      }
+    },
+    "xai/grok-build-0.1": {
+      id: "xai/grok-build-0.1",
+      family: "grok",
+      reasoning: false,
+      temperature: true,
+      toolCall: true,
+      modalities: {
+        input: ["text", "image"],
+        output: ["text"]
+      },
+      limit: {
+        context: 256000,
+        output: 32768
+      }
+    },
+    "x-ai/grok-build-0.1": {
+      id: "x-ai/grok-build-0.1",
+      family: "grok",
+      reasoning: false,
+      temperature: true,
+      toolCall: true,
+      modalities: {
+        input: ["text", "image"],
+        output: ["text"]
+      },
+      limit: {
+        context: 256000,
+        output: 32768
+      }
     }
   };
 });
@@ -78539,14 +78630,9 @@ var init_claude_code_plugin_loader = __esm(() => {
   init_hook_loader();
 });
 
-// packages/omo-opencode/src/features/claude-code-plugin-loader/index.ts
-var init_claude_code_plugin_loader2 = __esm(() => {
-  init_claude_code_plugin_loader();
-});
-
 // packages/omo-opencode/src/shared/plugin-command-discovery.ts
 var init_plugin_command_discovery = __esm(() => {
-  init_claude_code_plugin_loader2();
+  init_claude_code_plugin_loader();
 });
 
 // packages/omo-opencode/src/shared/session-category-registry.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode",
-  "version": "5.0.0-beta.31",
+  "version": "5.0.0-beta.32",
   "description": "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   "main": "./dist/index.js",
   "types": "dist/index.d.ts",
@@ -113,6 +113,7 @@
     "install:codex-dev": "bun run script/build-codex-install.ts && bun run script/install-codex-dev.ts",
     "build:codex-plugin": "npm --prefix packages/omo-codex/plugin ci && bun run --cwd packages/omo-codex/plugin build",
     "build:senpi-plugin": "bun run build:lsp-daemon && bun run build:ast-grep-mcp && bun run build:senpi-plugin:stage",
+    "build:senpi-plugin:native": "node packages/omo-senpi/plugin/scripts/stage-lsp-daemon-runtime.mjs && node packages/omo-senpi/plugin/scripts/stage-ast-grep-mcp-runtime.mjs && node packages/omo-senpi/plugin/scripts/stage-agent-toolkit.mjs && node packages/omo-senpi/plugin/scripts/build-extension.mjs && node packages/omo-senpi/plugin/scripts/sync-skills.mjs && node packages/omo-senpi/plugin/scripts/embed-directive.mjs --check && node packages/omo-senpi/plugin/scripts/build-install.mjs",
     "build:senpi-plugin:stage": "bun run build:materialize-frontend && node packages/omo-senpi/plugin/scripts/stage-lsp-daemon-runtime.mjs && node packages/omo-senpi/plugin/scripts/stage-ast-grep-mcp-runtime.mjs && node packages/omo-senpi/plugin/scripts/stage-agent-toolkit.mjs && node packages/omo-senpi/plugin/scripts/build-extension.mjs && node packages/omo-senpi/plugin/scripts/sync-skills.mjs && node packages/omo-senpi/plugin/scripts/embed-directive.mjs --check && node packages/omo-senpi/plugin/scripts/build-install.mjs",
     "build:materialize-frontend": "node packages/omo-codex/plugin/scripts/materialize-shared-upstreams.mjs --strict",
     "build:shared-skills-assets": "bun run build:materialize-frontend && rm -rf dist/skills && cp -R packages/shared-skills/skills dist/skills",
@@ -181,7 +182,7 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@code-yeongyu/senpi": "2026.8.31",
+    "@code-yeongyu/senpi": "2026.9.2",
     "@oh-my-opencode/agents-md-core": "workspace:*",
     "@oh-my-opencode/ast-grep-mcp": "workspace:*",
     "@oh-my-opencode/boulder-state": "workspace:*",
@@ -222,18 +223,18 @@
     "typescript": "^7.0.2"
   },
   "optionalDependencies": {
-    "oh-my-opencode-darwin-arm64": "5.0.0-beta.31",
-    "oh-my-opencode-darwin-x64": "5.0.0-beta.31",
-    "oh-my-opencode-darwin-x64-baseline": "5.0.0-beta.31",
-    "oh-my-opencode-linux-arm64": "5.0.0-beta.31",
-    "oh-my-opencode-linux-arm64-musl": "5.0.0-beta.31",
-    "oh-my-opencode-linux-x64": "5.0.0-beta.31",
-    "oh-my-opencode-linux-x64-baseline": "5.0.0-beta.31",
-    "oh-my-opencode-linux-x64-musl": "5.0.0-beta.31",
-    "oh-my-opencode-linux-x64-musl-baseline": "5.0.0-beta.31",
-    "oh-my-opencode-windows-arm64": "5.0.0-beta.31",
-    "oh-my-opencode-windows-x64": "5.0.0-beta.31",
-    "oh-my-opencode-windows-x64-baseline": "5.0.0-beta.31"
+    "oh-my-opencode-darwin-arm64": "5.0.0-beta.32",
+    "oh-my-opencode-darwin-x64": "5.0.0-beta.32",
+    "oh-my-opencode-darwin-x64-baseline": "5.0.0-beta.32",
+    "oh-my-opencode-linux-arm64": "5.0.0-beta.32",
+    "oh-my-opencode-linux-arm64-musl": "5.0.0-beta.32",
+    "oh-my-opencode-linux-x64": "5.0.0-beta.32",
+    "oh-my-opencode-linux-x64-baseline": "5.0.0-beta.32",
+    "oh-my-opencode-linux-x64-musl": "5.0.0-beta.32",
+    "oh-my-opencode-linux-x64-musl-baseline": "5.0.0-beta.32",
+    "oh-my-opencode-windows-arm64": "5.0.0-beta.32",
+    "oh-my-opencode-windows-x64": "5.0.0-beta.32",
+    "oh-my-opencode-windows-x64-baseline": "5.0.0-beta.32"
   },
   "overrides": {
     "@earendil-works/pi-agent-core": "0.84.2",
@@ -251,6 +252,6 @@
     "@code-yeongyu/comment-checker"
   ],
   "patchedDependencies": {
-    "@code-yeongyu/senpi@2026.8.31": "patches/@code-yeongyu%2Fsenpi@2026.8.31.patch"
+    "@code-yeongyu/senpi@2026.9.2": "patches/@code-yeongyu%2Fsenpi@2026.9.2.patch"
   }
 }

package/packages/lsp-core/src/lsp/client-diagnostics-freshness.integration.test.ts

@@ -2,6 +2,8 @@ import { writeFileSync } from "node:fs";
 
 import { afterEach, describe, expect, it } from "bun:test";
 
+import { ControlledClock } from "./controlled-clock-test-support.js";
+
 import {
 	createWorkspaceEditTestHarness,
 	diagnostic,
@@ -17,6 +19,7 @@ afterEach(async () => {
 
 describe("LspClient diagnostics freshness", () => {
 	it("#given a versionless publish that arrives after the current change #when no newer eligible publish arrives before quiescence #then diagnostics wait for that quiescence window and return the versionless payload", async () => {
+		const clock = new ControlledClock();
 		const context = await harness.makeClient(
 			{
 				publishDiagnostics: [
@@ -27,7 +30,7 @@ describe("LspClient diagnostics freshness", () => {
 					},
 				],
 			},
-			{ diagnosticsFreshnessTimeoutMs: 80, versionlessPublishQuiescenceMs: 20 },
+			{ diagnosticsFreshnessTimeoutMs: 80, versionlessPublishQuiescenceMs: 20, timerProvider: clock },
 		);
 		await context.client.openFile(context.source);
 		const versionlessDelivery = waitForEventCount(
@@ -35,42 +38,59 @@ describe("LspClient diagnostics freshness", () => {
 			(event) => event.type === "clientResponse" && event.method === "workspace/configuration",
 			1,
 		);
-		const startedAt = Date.now();
 		writeFileSync(context.source, "const after = 1;\n", "utf-8");
 		await context.client.openFile(context.source);
 		expect(await versionlessDelivery).toHaveLength(1);
 
-		const result = await context.client.diagnostics(context.source);
-		const elapsedMs = Date.now() - startedAt;
+		const pending = context.client.diagnostics(context.source);
+		await clock.waitForTimer(20);
+		expect(clock.scheduledDelays.at(-1)).toBe(20);
+		clock.advanceBy(20);
+		const result = await pending;
 
 		expect(result.items).toEqual([diagnostic("post-generation-versionless")]);
-		expect(elapsedMs).toBeGreaterThanOrEqual(15);
 	});
 
 	it("#given only a pre-generation versionless publish #when a newer local version asks for diagnostics #then the stale versionless publish is ignored and the request does not resolve clean", async () => {
+		const clock = new ControlledClock();
 		const context = await harness.makeClient(
 			{
 				publishDiagnostics: [
 					{
 						trigger: "didOpen",
 						diagnostics: [diagnostic("pre-generation-versionless")],
+						awaitClientDelivery: true,
 					},
 				],
 			},
-			{ diagnosticsFreshnessTimeoutMs: 300, versionlessPublishQuiescenceMs: 5 },
+			{ diagnosticsFreshnessTimeoutMs: 300, versionlessPublishQuiescenceMs: 5, timerProvider: clock },
 		);
 		await context.client.openFile(context.source);
-		expect((await context.client.diagnostics(context.source)).items).toEqual([diagnostic("pre-generation-versionless")]);
+		await waitForEventCount(
+			context.events,
+			(event) => event.type === "clientResponse" && event.method === "workspace/configuration",
+			1,
+		);
+		const initial = context.client.diagnostics(context.source);
+		await clock.waitForTimer(5);
+		expect(clock.scheduledDelays.at(-1)).toBe(5);
+		clock.advanceBy(5);
+		expect((await initial).items).toEqual([diagnostic("pre-generation-versionless")]);
 		writeFileSync(context.source, "const after = 1;\n", "utf-8");
 		await context.client.openFile(context.source);
 
-		const result = await context.client.diagnostics(context.source);
+		const pending = context.client.diagnostics(context.source);
+		await clock.waitForTimer(300);
+		expect(clock.scheduledDelays.at(-1)).toBe(300);
+		clock.advanceBy(300);
+		const result = await pending;
 
 		expect(result.items).toEqual([]);
 		expect(result.transientError?.kind).toBe("freshness_timeout");
 	});
 
 	it("#given stale and future publish versions #when diagnostics target the current version #then neither stale nor future diagnostics satisfy the request", async () => {
+		const staleClock = new ControlledClock();
 		const stale = await harness.makeClient(
 			{
 				publishDiagnostics: [
@@ -82,7 +102,7 @@ describe("LspClient diagnostics freshness", () => {
 					},
 				],
 			},
-			{ diagnosticsFreshnessTimeoutMs: 100, versionlessPublishQuiescenceMs: 5 },
+			{ diagnosticsFreshnessTimeoutMs: 100, versionlessPublishQuiescenceMs: 5, timerProvider: staleClock },
 		);
 		await stale.client.openFile(stale.source);
 		const staleDelivery = waitForEventCount(
@@ -94,13 +114,17 @@ describe("LspClient diagnostics freshness", () => {
 		await stale.client.openFile(stale.source);
 		expect(await staleDelivery).toHaveLength(1);
 
-		const staleResult = await stale.client.diagnostics(stale.source);
+		const stalePending = stale.client.diagnostics(stale.source);
+		await staleClock.waitForTimer(100);
+		staleClock.advanceBy(100);
+		const staleResult = await stalePending;
 
 		expect(staleResult.items).toEqual([]);
 		expect(staleResult.transientError?.kind).toBe("freshness_timeout");
 
 		await harness.cleanup();
 
+		const futureClock = new ControlledClock();
 		const future = await harness.makeClient(
 			{
 				publishDiagnostics: [
@@ -112,7 +136,7 @@ describe("LspClient diagnostics freshness", () => {
 					},
 				],
 			},
-			{ diagnosticsFreshnessTimeoutMs: 100, versionlessPublishQuiescenceMs: 5 },
+			{ diagnosticsFreshnessTimeoutMs: 100, versionlessPublishQuiescenceMs: 5, timerProvider: futureClock },
 		);
 		await future.client.openFile(future.source);
 		const futureDelivery = waitForEventCount(
@@ -124,7 +148,10 @@ describe("LspClient diagnostics freshness", () => {
 		await future.client.openFile(future.source);
 		expect(await futureDelivery).toHaveLength(1);
 
-		const futureResult = await future.client.diagnostics(future.source);
+		const futurePending = future.client.diagnostics(future.source);
+		await futureClock.waitForTimer(100);
+		futureClock.advanceBy(100);
+		const futureResult = await futurePending;
 
 		expect(futureResult.items).toEqual([]);
 		expect(futureResult.transientError?.kind).toBe("freshness_timeout");
@@ -136,7 +163,7 @@ describe("LspClient diagnostics freshness", () => {
 				capabilities: { diagnosticProvider: { interFileDependencies: false, workspaceDiagnostics: false } },
 				diagnosticResponses: [
 					{
-						delayMs: 200,
+						releaseOnDidChange: true,
 						report: { kind: "full", resultId: "v1", items: [diagnostic("pull-stale")] },
 					},
 					{
@@ -248,19 +275,20 @@ describe("LspClient diagnostics freshness", () => {
 	});
 
 	it("#given a server without pull support that never publishes diagnostics #when diagnostics run on a clean file #then the request resolves clean after the freshness window instead of reporting a timeout", async () => {
+		const clock = new ControlledClock();
 		const context = await harness.makeClient(
 			{},
-			{ diagnosticsFreshnessTimeoutMs: 60, versionlessPublishQuiescenceMs: 5 },
+			{ diagnosticsFreshnessTimeoutMs: 60, versionlessPublishQuiescenceMs: 5, timerProvider: clock },
 		);
 
-		const startedAt = Date.now();
-		const result = await context.client.diagnostics(context.source);
-		const elapsedMs = Date.now() - startedAt;
+		const pending = context.client.diagnostics(context.source);
+		await clock.waitForTimer(60);
+		expect(clock.scheduledDelays.at(-1)).toBe(60);
+		clock.advanceBy(60);
+		const result = await pending;
 
 		expect(result.transientError).toBeUndefined();
 		expect(result.items).toEqual([]);
-		// The full freshness window is still honored so a slow publisher can win.
-		expect(elapsedMs).toBeGreaterThanOrEqual(45);
 	});
 
 	it("#given a pull-supported server that cached diagnostics for an older document version #when the file changes and a later pull is rejected as unsupported without any publish #then the fallback resolves empty instead of returning the stale cached diagnostics", async () => {

package/packages/lsp-core/src/lsp/client-diagnostics-pull-timeout.test.ts

@@ -0,0 +1,64 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { afterEach, describe, expect, it } from "bun:test";
+
+import { ControlledClock } from "./controlled-clock-test-support.js";
+import { LspClient } from "./client.js";
+import { LspRequestTimeoutError } from "./errors.js";
+import type { ResolvedServer } from "./types.js";
+
+const fakeServer: ResolvedServer = {
+	id: "pull-timeout-fake",
+	command: ["pull-timeout-fake"],
+	extensions: [".ts"],
+	priority: 0,
+};
+
+class HangingPullClient extends LspClient {
+	readonly grantedPullTimeouts: number[] = [];
+
+	constructor(root: string, private readonly clock: ControlledClock) {
+		super(root, fakeServer, { diagnosticsFreshnessTimeoutMs: 50, versionlessPublishQuiescenceMs: 5, timerProvider: clock });
+		this.setDiagnosticPullSupported(true);
+	}
+
+	protected override async sendNotification(): Promise<void> {}
+
+	protected override async sendRequest<T>(
+		method: string,
+		...args: [] | [unknown] | [unknown, { timeoutMs?: number; signal?: AbortSignal }]
+	): Promise<T> {
+		if (method !== "textDocument/diagnostic") {
+			throw new Error(`unexpected request in hanging-pull fixture: ${method}`);
+		}
+		const timeoutMs = args[1]?.timeoutMs ?? 0;
+		this.grantedPullTimeouts.push(timeoutMs);
+		this.clock.advanceBy(timeoutMs);
+		throw new LspRequestTimeoutError(method);
+	}
+}
+
+describe("LspClient diagnostics pull timeout conversion", () => {
+	let root: string | null = null;
+
+	afterEach(() => {
+		if (root !== null) rmSync(root, { recursive: true, force: true });
+		root = null;
+	});
+
+	it("#given a pull that exhausts the freshness window #when diagnostics settle #then the timeout converts to freshness_timeout instead of rejecting", async () => {
+		root = mkdtempSync(join(tmpdir(), "lsp-pull-timeout-"));
+		const source = join(root, "sample.ts");
+		writeFileSync(source, "const value = 1;\n", "utf-8");
+		const clock = new ControlledClock();
+		const client = new HangingPullClient(root, clock);
+
+		const result = await client.diagnostics(source);
+
+		expect(client.grantedPullTimeouts).toEqual([50]);
+		expect(result.items).toEqual([]);
+		expect(result.transientError?.kind).toBe("freshness_timeout");
+	});
+});

package/packages/lsp-core/src/lsp/client.ts

@@ -19,6 +19,7 @@ import type {
 } from "./types.js";
 import { LspRequestTimeoutError } from "./errors.js";
 import { WorkspaceDocumentState } from "./workspace-document-state.js";
+import type { TimerProvider } from "./timer-provider.js";
 import type { LspRenameResult, WorkspaceEditCommitIo } from "./workspace-edit-types.js";
 import { WorkspaceMutationController } from "./workspace-mutation-controller.js";
 
@@ -36,6 +37,7 @@ export interface LspDiagnosticsResult {
 export interface LspClientOptions extends LspClientTimeoutOptions {
 	readonly diagnosticsFreshnessTimeoutMs?: number;
 	readonly versionlessPublishQuiescenceMs?: number;
+	readonly timerProvider?: TimerProvider;
 }
 
 export class LspClient extends LspClientConnection {
@@ -52,6 +54,7 @@ export class LspClient extends LspClientConnection {
 			(method, params) => this.sendNotification(method, params),
 			(uri) => this.diagnosticsStore.delete(uri),
 			{
+				timerProvider: this.timerProvider,
 				versionlessPublishQuiescenceMs:
 					options.versionlessPublishQuiescenceMs ?? VERSIONLESS_PUBLISH_QUIESCENCE_MS,
 			},
@@ -207,7 +210,7 @@ export class LspClient extends LspClientConnection {
 		const absPath = this.resolveWorkspacePath(filePath);
 		const uri = pathToFileURL(absPath).href;
 		await this.openFile(absPath);
-		const deadlineAt = Date.now() + this.diagnosticsFreshnessTimeoutMs;
+		const deadlineAt = this.timerProvider.now() + this.diagnosticsFreshnessTimeoutMs;
 
 		for (;;) {
 			signal?.throwIfAborted();
@@ -220,7 +223,7 @@ export class LspClient extends LspClientConnection {
 			if (!pushFallbackOnly) {
 				const cached = this.documents.getPullCache(snapshot);
 				try {
-					const remainingMs = deadlineAt - Date.now();
+					const remainingMs = deadlineAt - this.timerProvider.now();
 					if (remainingMs <= 0) return this.freshnessTimeout(absPath);
 					const result = await this.sendRequest<{ items?: Diagnostic[]; kind?: string; resultId?: string }>(
 						"textDocument/diagnostic",
@@ -262,7 +265,7 @@ export class LspClient extends LspClientConnection {
 
 			if (!pushFallbackOnly) continue;
 
-			const remainingMs = deadlineAt - Date.now();
+			const remainingMs = deadlineAt - this.timerProvider.now();
 			if (remainingMs <= 0) {
 				// A server that never advertised pull diagnostics (or rejected the pull
 				// method) and has never published for this document stays silent for a

package/packages/lsp-core/src/lsp/controlled-clock-test-support.ts

@@ -0,0 +1,61 @@
+import type { TimerProvider } from "./timer-provider.js";
+
+interface ControlledTimer {
+	readonly at: number;
+	readonly callback: () => void;
+	cancelled: boolean;
+}
+
+interface TimerWaiter {
+	readonly delayMs: number | undefined;
+	readonly resolve: () => void;
+}
+
+/**
+ * Deterministic TimerProvider for tests: timers fire only through advanceBy(),
+ * and waitForTimer(delayMs) resolves once a timer with exactly that delay is
+ * scheduled, so tests order themselves behind the timer they intend to fire.
+ */
+export class ControlledClock implements TimerProvider {
+	private readonly timers: ControlledTimer[] = [];
+	private currentTime = 0;
+	private readonly timerWaiters = new Set<TimerWaiter>();
+	readonly scheduledDelays: number[] = [];
+
+	readonly now = (): number => this.currentTime;
+	readonly setTimeout = (callback: () => void, delayMs: number): ReturnType<typeof setTimeout> => {
+		const timer: ControlledTimer = { at: this.currentTime + delayMs, callback, cancelled: false };
+		this.scheduledDelays.push(delayMs);
+		this.timers.push(timer);
+		for (const waiter of this.timerWaiters) {
+			if (waiter.delayMs === undefined || waiter.delayMs === delayMs) {
+				this.timerWaiters.delete(waiter);
+				waiter.resolve();
+			}
+		}
+		return timer as unknown as ReturnType<typeof setTimeout>;
+	};
+	readonly clearTimeout = (handle: ReturnType<typeof setTimeout>): void => {
+		(handle as unknown as { cancelled: boolean }).cancelled = true;
+	};
+
+	waitForTimer(delayMs?: number): Promise<void> {
+		const hasTimer = this.timers.some(
+			(timer) => !timer.cancelled && (delayMs === undefined || timer.at === this.currentTime + delayMs),
+		);
+		if (hasTimer) return Promise.resolve();
+		return new Promise((resolve) => {
+			this.timerWaiters.add({ delayMs, resolve });
+		});
+	}
+
+	advanceBy(delayMs: number): void {
+		this.currentTime += delayMs;
+		for (;;) {
+			const index = this.timers.findIndex((timer) => timer.at <= this.currentTime);
+			if (index < 0) return;
+			const timer = this.timers.splice(index, 1)[0];
+			if (timer && !timer.cancelled) timer.callback();
+		}
+	}
+}

package/packages/lsp-core/src/lsp/fixtures/workspace-edit-server.mjs

@@ -8,6 +8,7 @@ let nextServerRequestId = 10_000;
 let renameIndex = 0;
 let diagnosticIndex = 0;
 const pendingServerRequests = new Map();
+const releasedDiagnosticResponses = [];
 
 function record(event) {
 	appendFileSync(eventsPath, `${JSON.stringify(event)}\n`, "utf-8");
@@ -146,8 +147,7 @@ function handleRequest(message) {
 			setTimeout(() => process.exit(0), delay);
 			return;
 		}
-		const delay = Number(step?.delayMs ?? 0);
-		setTimeout(() => {
+		const sendDiagnosticResponse = () => {
 			if (step?.error) {
 				record({ type: "serverError", method: "textDocument/diagnostic", error: step.error });
 				sendError(message.id, step.error.code, step.error.message);
@@ -156,7 +156,13 @@ function handleRequest(message) {
 			const result = step?.report ?? { items: scenario.diagnostics ?? [] };
 			record({ type: "serverResponse", method: "textDocument/diagnostic", result });
 			sendResponse(message.id, result);
-		}, delay);
+		};
+		if (step?.releaseOnDidChange === true) {
+			releasedDiagnosticResponses.push(sendDiagnosticResponse);
+		} else {
+			const delay = Number(step?.delayMs ?? 0);
+			setTimeout(sendDiagnosticResponse, delay);
+		}
 		return;
 	}
 	if (message.method === "shutdown") {
@@ -190,6 +196,7 @@ function handleNotification(message) {
 	}
 	if (message.method === "textDocument/didChange") {
 		applyPublishSteps("didChange", message.params.textDocument.uri, message.params.textDocument.version);
+		for (const release of releasedDiagnosticResponses.splice(0)) release();
 	}
 	if (message.method === "exit") process.exit(0);
 }

package/packages/lsp-core/src/lsp/timer-provider.ts

@@ -0,0 +1,13 @@
+export type TimerHandle = ReturnType<typeof setTimeout>;
+
+export interface TimerProvider {
+	readonly now: () => number;
+	readonly setTimeout: (callback: () => void, delayMs: number) => TimerHandle;
+	readonly clearTimeout: (handle: TimerHandle) => void;
+}
+
+export const realTimerProvider: TimerProvider = {
+	now: () => Date.now(),
+	setTimeout: (callback, delayMs) => setTimeout(callback, delayMs),
+	clearTimeout: (handle) => clearTimeout(handle),
+};