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, 86 insertions, 0 deletions

diff --git a/packages/lsp/src/diagnostics.ts b/packages/lsp/src/diagnostics.ts
new file mode 100644
index 0000000..ea18811
--- /dev/null
+++ b/packages/lsp/src/diagnostics.ts
@@ -0,0 +1,86 @@
+/**
+ * Diagnostics — merge push (textDocument/publishDiagnostics) + pull
+ * (textDocument/diagnostic) per file, dedupe, and format.
+ */
+
+export interface Diagnostic {
+	readonly range: {
+		readonly start: { readonly line: number; readonly character: number };
+		readonly end: { readonly line: number; readonly character: number };
+	};
+	readonly severity?: number;
+	readonly source?: string;
+	readonly message: string;
+	readonly code?: string | number;
+}
+
+export interface PublishDiagnosticsParams {
+	readonly uri: string;
+	readonly diagnostics: readonly Diagnostic[];
+}
+
+export interface DocumentDiagnosticReport {
+	readonly kind: "full" | "unchanged";
+	readonly items?: readonly Diagnostic[];
+}
+
+const severityNames: Record<number, string> = {
+	1: "ERROR",
+	2: "WARNING",
+	3: "INFO",
+	4: "HINT",
+};
+
+export class DiagnosticsStore {
+	private pushDiagnostics = new Map<string, readonly Diagnostic[]>();
+	private pullDiagnostics = new Map<string, readonly Diagnostic[]>();
+
+	setPushDiagnostics(params: PublishDiagnosticsParams): void {
+		this.pushDiagnostics.set(params.uri, params.diagnostics);
+	}
+
+	setPullDiagnostics(uri: string, report: DocumentDiagnosticReport): void {
+		if (report.kind === "full" && report.items) {
+			this.pullDiagnostics.set(uri, report.items);
+		}
+	}
+
+	getMerged(uri: string): readonly Diagnostic[] {
+		const push = this.pushDiagnostics.get(uri) ?? [];
+		const pull = this.pullDiagnostics.get(uri) ?? [];
+		return dedupeDiagnostics([...push, ...pull]);
+	}
+
+	format(uri: string): string {
+		const diags = this.getMerged(uri);
+		if (diags.length === 0) return "";
+		const lines: string[] = [];
+		for (const d of diags) {
+			const sev = d.severity ? (severityNames[d.severity] ?? "UNKNOWN") : "UNKNOWN";
+			const line = d.range.start.line + 1;
+			const col = d.range.start.character + 1;
+			const src = d.source ? ` [${d.source}]` : "";
+			const code = d.code ? ` (${d.code})` : "";
+			lines.push(`${sev}${code}${src} L${line}:${col}: ${d.message}`);
+		}
+		return lines.join("\n");
+	}
+}
+
+function diagnosticKey(d: Diagnostic): string {
+	const r = d.range;
+	return `${r.start.line}:${r.start.character}-${r.end.line}:${r.end.character}:${d.severity ?? 0}:${d.message}`;
+}
+
+function dedupeDiagnostics(diags: readonly Diagnostic[]): readonly Diagnostic[] {
+	const seen = new Set<string>();
+	const result: Diagnostic[] = [];
+	for (const d of diags) {
+		const key = diagnosticKey(d);
+		if (!seen.has(key)) {
+			seen.add(key);
+			result.push(d);
+		}
+	}
+	return result;
+}