feat(lsp,cwd): LSP integration + per-conversation cwd; fix cache-warming cache bust

LSP + per-conversation CWD feature:
- new bundled `lsp` extension: hand-rolled JSON-RPC codec (framing/rpc), lazy
  one-server-per-(serverID,root), per-cwd config resolution, on-demand `lsp` tool
- `conversation-store`: getCwd/setCwd (cwdKey); `session-orchestrator` defaults a
  turn's cwd from the store
- `transport-http`: cwd + lsp status endpoints; wire types in transport-contract
- host-bin: register lsp; config wiring

Cache-warming fix (the warm read 0% on the first reheat after a message):
- warm assembled tools under a different cwd than the real turn (a reheat sends no
  cwd, and the warm service had no store fallback). The skills filter rewrites the
  cwd-sensitive `load_skill` description, so the tools block — the first bytes of
  the prompt-cache prefix — diverged and the cache missed entirely. Warm now
  resolves cwd as opts.cwd ?? conversationStore.getCwd(), mirroring handleMessage.
- capture warm sends as `provider.request` spans flagged `warm:true` (thread a
  child logger into providerOpts) so warm vs real bodies are diffable (obs §3.1).
- kernel logger: span-close now merges child-bound attrs like span-open, so a
  `warm:true` query finds the closed span (with usage/status), not just the open.

Tests: warm forwards a warm-flagged logger; warm falls back to stored cwd; logger
open/close attr consistency. Full suite green (873).

1 files changed, 204 insertions, 0 deletions

diff --git a/packages/lsp/src/manager.test.ts b/packages/lsp/src/manager.test.ts
new file mode 100644
index 0000000..3e8e60e
--- /dev/null
+++ b/packages/lsp/src/manager.test.ts
@@ -0,0 +1,204 @@
+import { describe, expect, it } from "vitest";
+import type { FileWatcher, FsAccess, SpawnedProcess, SpawnProcess } from "./client.js";
+import { encode } from "./framing.js";
+import { LspManager } from "./manager.js";
+
+function makeAutoHandshakeSpawn(): SpawnProcess {
+	return () => {
+		let messageHandler: ((data: Uint8Array) => void) | null = null;
+
+		const proc: SpawnedProcess = {
+			stdin: {
+				write: (bytes: Uint8Array) => {
+					// Parse the message to handle initialize handshake
+					const decoded = new TextDecoder().decode(bytes);
+					const headerEnd = decoded.indexOf("\r\n\r\n");
+					if (headerEnd === -1) return;
+					const json = decoded.slice(headerEnd + 4);
+					try {
+						const msg = JSON.parse(json);
+						if (msg.method === "initialize") {
+							// Send back initialize response
+							setTimeout(() => {
+								const response = JSON.stringify({
+									jsonrpc: "2.0",
+									id: msg.id,
+									result: { capabilities: {} },
+								});
+								messageHandler?.(encode(response));
+							}, 5);
+						}
+						// Ignore other messages
+					} catch {
+						// ignore parse errors
+					}
+				},
+			},
+			stdout: {
+				on: (_event: string, cb: (data: Uint8Array) => void) => {
+					messageHandler = cb;
+				},
+			},
+			pid: 12345,
+			kill: () => {},
+		};
+		return proc;
+	};
+}
+
+function noopFileWatcher(): FileWatcher {
+	return () => ({ close: () => {} });
+}
+
+function fakeFs(files: Record<string, string> = {}): FsAccess {
+	return {
+		readText: async (path) => files[path] ?? "",
+		exists: async (path) => path in files,
+	};
+}
+
+describe("manager", () => {
+	it("status(cwd) lazy-spawns matching servers and reports connected", async () => {
+		const manager = new LspManager({
+			spawn: makeAutoHandshakeSpawn(),
+			fileWatcher: noopFileWatcher(),
+			fs: fakeFs({
+				"/project/tsconfig.json": "{}",
+				"/project/.dispatch/lsp.json": JSON.stringify({
+					servers: {
+						test: {
+							command: ["test-lsp", "--stdio"],
+							extensions: [".ts"],
+							rootMarkers: ["tsconfig.json"],
+						},
+					},
+				}),
+			}),
+		});
+
+		const statuses = await manager.status("/project");
+		expect(statuses).toHaveLength(1);
+		expect(statuses[0]?.id).toBe("test");
+		expect(statuses[0]?.state).toBe("connected");
+		expect(statuses[0]?.root).toBe("/project");
+	}, 10000);
+
+	it("concurrent status for the same root spawns one process", async () => {
+		let spawnCount = 0;
+		const countingSpawn: SpawnProcess = () => {
+			spawnCount++;
+			return makeAutoHandshakeSpawn()([], { cwd: "/project" });
+		};
+
+		const manager = new LspManager({
+			spawn: countingSpawn,
+			fileWatcher: noopFileWatcher(),
+			fs: fakeFs({
+				"/project/tsconfig.json": "{}",
+				"/project/.dispatch/lsp.json": JSON.stringify({
+					servers: {
+						test: {
+							command: ["test-lsp"],
+							extensions: [".ts"],
+							rootMarkers: ["tsconfig.json"],
+						},
+					},
+				}),
+			}),
+		});
+
+		const [s1, s2] = await Promise.all([manager.status("/project"), manager.status("/project")]);
+
+		expect(s1).toHaveLength(1);
+		expect(s2).toHaveLength(1);
+		expect(spawnCount).toBe(1);
+	}, 10000);
+
+	it("a failing spawn reports state:error and is not retried", async () => {
+		let spawnCount = 0;
+		const failingSpawn: SpawnProcess = () => {
+			spawnCount++;
+			throw new Error("spawn failed");
+		};
+
+		const manager = new LspManager({
+			spawn: failingSpawn,
+			fileWatcher: noopFileWatcher(),
+			fs: fakeFs({
+				"/project/tsconfig.json": "{}",
+				"/project/.dispatch/lsp.json": JSON.stringify({
+					servers: {
+						test: {
+							command: ["test-lsp"],
+							extensions: [".ts"],
+							rootMarkers: ["tsconfig.json"],
+						},
+					},
+				}),
+			}),
+		});
+
+		const s1 = await manager.status("/project");
+		expect(s1[0]?.state).toBe("error");
+		expect(spawnCount).toBe(1);
+
+		// Second call should not retry
+		const s2 = await manager.status("/project");
+		expect(s2[0]?.state).toBe("error");
+		expect(spawnCount).toBe(1);
+	});
+
+	it("shutdownAll kills all spawned processes (incl. sidecars)", async () => {
+		let killed = false;
+		const trackableSpawn: SpawnProcess = () => {
+			const proc = makeAutoHandshakeSpawn()([], { cwd: "/project" });
+			return {
+				...proc,
+				kill: () => {
+					killed = true;
+				},
+			};
+		};
+
+		const manager = new LspManager({
+			spawn: trackableSpawn,
+			fileWatcher: noopFileWatcher(),
+			fs: fakeFs({
+				"/project/tsconfig.json": "{}",
+				"/project/.dispatch/lsp.json": JSON.stringify({
+					servers: {
+						test: {
+							command: ["test-lsp"],
+							extensions: [".ts"],
+							rootMarkers: ["tsconfig.json"],
+						},
+					},
+				}),
+			}),
+		});
+
+		await manager.status("/project");
+		manager.shutdownAll();
+		expect(killed).toBe(true);
+	}, 10000);
+
+	it("resolves config per cwd (distinct cwds, opencode.json fallback)", async () => {
+		const manager = new LspManager({
+			spawn: makeAutoHandshakeSpawn(),
+			fileWatcher: noopFileWatcher(),
+			fs: fakeFs({
+				"/proj-a/.dispatch/lsp.json": JSON.stringify({
+					servers: { a: { command: ["a-lsp"], extensions: [".a"], rootMarkers: [] } },
+				}),
+				"/proj-b/opencode.json": JSON.stringify({
+					lsp: { b: { command: ["b-lsp"], extensions: [".b"] } },
+				}),
+			}),
+		});
+
+		const a = await manager.status("/proj-a");
+		const b = await manager.status("/proj-b");
+		expect(a.map((s) => s.id)).toEqual(["a"]);
+		expect(b.map((s) => s.id)).toEqual(["b"]);
+	}, 10000);
+});