Wave B: the native message record — input events, projection, adapter death

The chat record is now pi-native agent history (LhMessage[]), the AI SDK's
UIMessage transcript contract is gone from the server, and every client turn
arrives as ONE explicit input event.

Core (new):
- src/core/native-messages.ts — the LhMessage taxonomy (user/assistant/
  toolResult + lhMarker customs: verdict, probe-handoff, subagent-steer,
  subagent-abort, plan-block), constructors, and toLlmMessages — the single
  model-facing seam (convertToLlm): strips ids, flattens markers to user
  text, drops UI-only plan-blocks, synthesizes INTERRUPTED results for
  dangling aborted calls, never throws.
- src/core/projection.ts — projectNative: the one-way native → UIMessage
  projection (consecutive assistant+toolResult runs group into one
  assistant view message; toolResults attach backward by toolCallId;
  markers project to data parts; plan-blocks splice after the last
  successful plan_init). Every existing consumer reads through it.
- src/core/input-events.ts — the ChatInput union (text/answer/verdict/
  continue), parseChatInput validation, and inputAppends (answer targets
  the dangling question call or 400s; verdict = optional note user
  message + native verdict marker).

Server:
- chat-handler.ts — the turn root takes {chatId, input}; write-ahead
  persists input appends + claimed steers before the turn; claimSteers
  coalesces the whole queue with the handler's steerDelivered filter as
  the dedupe seam; teacher-vs-prober branch on hasProbeDone.
- turn-service.ts — persistTurn stamps ids, drops clean question
  placeholder toolResults (the record ends at the unanswered call),
  emits plan-block markers idempotently (plan-blocks.ts rewrite), and
  persists abort partials.
- ui-stream.ts — PiTurnSpec takes the native base; the wire dialect is
  unchanged. jobs.ts steers are native markers (steer_<jobId> dedup ids);
  waitForIdle reads danglingQuestionOf. teacher-agent.ts wires
  convertToLlm: toLlmMessages. record-adapter.ts DELETED wholesale.
- GET /api/chats/[id] serves messages: projectNative(record.messages).

Client:
- chat-transport.ts — the 409 retry is IDENTITY (re-POST the same event
  body after the turn settles — the event was never persisted
  pre-acceptance; the merge logic is gone). The transport consumes the
  stashed input event via prepareSendMessagesRequest and throws loudly on
  a missing stash.
- chat.tsx — every send call site stashes exactly one ChatInput event
  (text, answer, verdict, continue) before invoking the SDK send.

Tests: full native migration (chat-flow rewritten to input events and
native record pins; jobs/extraction/demos/graph/usage/plan-blocks/
probe-done/reattach-transport converted; record-adapter.test.ts deleted;
chat-transport tests pin the identity retry). 982/982, typecheck, lint,
build all green.

tests/probe-done.test.ts

@@ -3,13 +3,18 @@
  * Server-side; three outcomes: refusal while a question is open, refusal
  * after the probe is already concluded, ok + handoff queued. The handoff
  * rides the wake pipeline (deliver injected here — no server seam import).
+ * Wave B: the record is native history — fixtures are pi messages, the
+ * pending-question gate is the dangling-question scan, and the handoff is
+ * a native marker (customType probe-handoff, HANDOFF_TEXT content).
  */
 import assert from "node:assert/strict";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { after, describe, it } from "node:test";
 import { probeDoneTool } from "../src/agent/tools/probe.ts";
-import type { ProbeHandoffSteerMessage } from "../src/core/contracts.ts";
+import type { SteerMessage } from "../src/core/contracts.ts";
+import type { LhMessage } from "../src/core/native-messages.ts";
+import { HANDOFF_TEXT } from "../src/core/contracts.ts";
 import { chatStore } from "../src/store/chats.ts";
 import { PATHS } from "../config.ts";
 
@@ -40,6 +45,22 @@ const ASSESSMENT = {
 	summary: "Enter at the formal definition.",
 };
 
+/** A native assistant message carrying one tool call (the minimal fixture
+ *  shape the scans read — role assistant, content blocks). */
+function assistantWithCall(id: string, toolName: string, args: unknown): LhMessage {
+	return {
+		id,
+		role: "assistant",
+		content: [{ type: "toolCall", id: `call_${id}`, name: toolName, arguments: args as never }],
+		api: "openai-completions",
+		provider: "openrouter",
+		model: "test",
+		usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		stopReason: "stop",
+		timestamp: Date.now(),
+	} as never;
+}
+
 async function execute(tools: ReturnType<typeof probeDoneTool>, input: unknown) {
 	const t = tools.probe_done!;
 	assert.ok(typeof t.execute === "function");
@@ -49,7 +70,7 @@ async function execute(tools: ReturnType<typeof probeDoneTool>, input: unknown)
 describe("probe_done: the probe→planning seam", () => {
 	it("ok path: records the assessment and queues the handoff steer (deterministic id)", async () => {
 		const chatId = newChat("Probe: ok");
-		const delivered: ProbeHandoffSteerMessage[] = [];
+		const delivered: SteerMessage[] = [];
 		const tools = probeDoneTool({ chatId, chatStore, deliver: (s) => delivered.push(s) });
 
 		const res = await execute(tools, { assessment: ASSESSMENT });
@@ -57,19 +78,19 @@ describe("probe_done: the probe→planning seam", () => {
 		assert.equal(res.error, undefined);
 		assert.equal(delivered.length, 1, "the handoff is queued exactly once");
 		assert.equal(delivered[0]!.id, `steer_probe_${chatId}`);
-		assert.equal((delivered[0]!.metadata as { probeHandoff: { chatId: string } }).probeHandoff.chatId, chatId);
+		// Native marker (Wave B): the model-facing HANDOFF_TEXT rides content;
+		// the UI keys off customType; the chat id rides details.
+		assert.equal(delivered[0]!.customType, "probe-handoff");
+		assert.equal(delivered[0]!.content, HANDOFF_TEXT);
+		assert.equal((delivered[0]!.details as { chatId: string }).chatId, chatId);
 	});
 
 	it("REFUSES while a question is still open — resolve it first", async () => {
 		const chatId = newChat("Probe: open question");
 		chatStore.saveMessages(chatId, [
-			{
-				id: "m1",
-				role: "assistant",
-				parts: [{ type: "tool-quiz", state: "input-available", input: { question: "q?" } }],
-			} as never,
+			assistantWithCall("m1", "quiz", { question: "q?", options: [{ label: "a" }], correctAnswer: "a" }),
 		]);
-		const delivered: ProbeHandoffSteerMessage[] = [];
+		const delivered: SteerMessage[] = [];
 		const tools = probeDoneTool({ chatId, chatStore, deliver: (s) => delivered.push(s) });
 
 		const res = await execute(tools, { assessment: ASSESSMENT });
@@ -81,13 +102,18 @@ describe("probe_done: the probe→planning seam", () => {
 	it("REFUSES a second conclusion — probe_done fires exactly once", async () => {
 		const chatId = newChat("Probe: twice");
 		chatStore.saveMessages(chatId, [
+			assistantWithCall("m1", "probe_done", { assessment: ASSESSMENT }),
 			{
-				id: "m1",
-				role: "assistant",
-				parts: [{ type: "tool-probe_done", state: "output-available", input: { assessment: ASSESSMENT }, output: { ok: true } }],
+				id: "m1r",
+				role: "toolResult",
+				toolCallId: "call_m1",
+				toolName: "probe_done",
+				content: [{ type: "text", text: "ok" }],
+				isError: false,
+				timestamp: Date.now(),
 			} as never,
 		]);
-		const delivered: ProbeHandoffSteerMessage[] = [];
+		const delivered: SteerMessage[] = [];
 		const tools = probeDoneTool({ chatId, chatStore, deliver: (s) => delivered.push(s) });
 
 		const res = await execute(tools, { assessment: ASSESSMENT });
@@ -115,4 +141,4 @@ describe("probe_done: the probe→planning seam", () => {
 		const res = await execute(tools, { assessment: ASSESSMENT });
 		assert.equal(res.ok, true, "ok:true even when the queue is lost — the next client message constructs the teacher off the transcript seam");
 	});
-});
+});