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).

2 files changed, 55 insertions, 1 deletions

diff --git a/packages/kernel/src/logging/logger.test.ts b/packages/kernel/src/logging/logger.test.ts
new file mode 100644
index 0000000..5d7bf45
--- /dev/null
+++ b/packages/kernel/src/logging/logger.test.ts
@@ -0,0 +1,45 @@
+import { describe, expect, it } from "vitest";
+import type { LogDeps, LogRecord, LogSink } from "../contracts/logging.js";
+import { createLogger } from "./logger.js";
+
+function harness() {
+	let idCounter = 0;
+	const deps: LogDeps = {
+		now: () => 1000 + idCounter * 10,
+		newId: () => `span-${++idCounter}`,
+	};
+	const records: LogRecord[] = [];
+	const sink: LogSink = { emit: (r) => records.push(r) };
+	return { logger: createLogger({ extensionId: "test" }, sink, deps), records };
+}
+
+describe("createLogger child-bound attributes", () => {
+	it("merges child-bound attrs into BOTH span-open and span-close records", () => {
+		const { logger, records } = harness();
+		// Bind `warm: true` via child() — mirrors the cache-warming capture path.
+		const warmLogger = logger.child({ conversationId: "c1", attrs: { warm: true } });
+
+		const span = warmLogger.span("provider.request", { model: "x" });
+		span.end({ attrs: { "usage.cacheReadTokens": 0 } });
+
+		const open = records.find((r) => r.kind === "span-open");
+		const close = records.find((r) => r.kind === "span-close");
+
+		// Open carries the bound attr (pre-existing behavior).
+		expect(open?.attributes?.warm).toBe(true);
+		// Close MUST carry it too, so a `warm = true` query finds the closed span
+		// (with its usage/status) — not just the open record.
+		expect(close?.attributes?.warm).toBe(true);
+		// Span-specific attrs from span()/end() are still present on close.
+		expect(close?.attributes?.model).toBe("x");
+		expect(close?.attributes?.["usage.cacheReadTokens"]).toBe(0);
+	});
+
+	it("omits attributes entirely when neither bound nor span attrs exist", () => {
+		const { logger, records } = harness();
+		const span = logger.span("bare");
+		span.end();
+		const close = records.find((r) => r.kind === "span-close");
+		expect(close?.attributes).toBeUndefined();
+	});
+});
diff --git a/packages/kernel/src/logging/logger.ts b/packages/kernel/src/logging/logger.ts
index 70bc18c..4d2a609 100644
--- a/packages/kernel/src/logging/logger.ts
+++ b/packages/kernel/src/logging/logger.ts
@@ -194,6 +194,15 @@ export function createLogger(
 				}
 
 				const hasAttrs = Object.keys(spanAttrsMutable).length > 0;
+				// Merge child-bound default attrs (state.attrs) the SAME way span-open
+				// does (buildSpanOpen). Without this, an attribute bound via
+				// `logger.child({ attrs })` appears on the span-open record but NOT the
+				// span-close record — so a query like `warm = true` can't find the
+				// closed span (with its usage/status). Open and close must agree.
+				const mergedCloseAttrs = mergeAttributes(
+					state.attrs,
+					hasAttrs ? spanAttrsMutable : undefined,
+				);
 				const hasLinks = links.length > 0;
 				const base = {
 					kind: "span-close" as const,
@@ -209,7 +218,7 @@ export function createLogger(
 					...(ctx.conversationId !== undefined ? { conversationId: ctx.conversationId } : {}),
 					...(ctx.turnId !== undefined ? { turnId: ctx.turnId } : {}),
 					...(mergedParent !== undefined ? { parentSpanId: mergedParent } : {}),
-					...(hasAttrs ? { attributes: { ...spanAttrsMutable } } : {}),
+					...(mergedCloseAttrs !== undefined ? { attributes: mergedCloseAttrs } : {}),
 					...(hasLinks ? { links: [...links] } : {}),
 					...(outcome?.body !== undefined ? { body: outcome.body } : {}),
 				};