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.

components/chat.tsx

@@ -26,7 +26,7 @@ import { DictationBar, useDictation } from "@/components/dictation";
 import { JobsContext } from "@/components/jobs-context";
 import { StatsBar } from "@/components/stats-bar";
 import { useActivity } from "@/components/activity-dock";
-import { isProviderKeyRefusal, mergeAdopted, type ChatSettings, type ModelSlotName } from "@/src/core";
+import { isProviderKeyRefusal, mergeAdopted, type ChatInput, type ChatSettings, type ModelSlotName } from "@/src/core";
 import { PlanBlock, PlanPopup, latestTree } from "@/components/plan-block";
 import { PlanMarginalia } from "@/components/plan-window";
 import { MermaidOverlay, SessionMermaidContext } from "@/components/session-overlay";
@@ -181,15 +181,35 @@ export function Chat({
 	// the per-render transport recreation can never capture a stale one.
 	const reattachSettledRef = useRef<() => void>(() => {});
 	const reattachLastIdRef = useRef<string | undefined>(undefined);
+	// THE INPUT STASH (Wave B input-events contract, owner ruling
+	// 2026-09-26): every SDK send maps to EXACTLY ONE explicit input event —
+	// the call site stashes the event here before invoking the SDK send, and
+	// the transport consumes it when building the POST body ({chatId, input};
+	// the client transcript never rides the wire). Consumed-on-read: a send
+	// with nothing stashed fails LOUDLY in the transport (a call-site bug —
+	// it must never silently re-send the previous event).
+	const pendingInputRef = useRef<ChatInput | null>(null);
+	const stashInput = (input: ChatInput) => {
+		pendingInputRef.current = input;
+	};
+	const takeInput = () => {
+		const input = pendingInputRef.current;
+		pendingInputRef.current = null;
+		return input ?? undefined;
+	};
 
 	const { messages, sendMessage, addToolOutput, setMessages, status, error, stop, clearError, resumeStream } =
 		useChat<TeacherUIMessage>({
 			id: chatId,
 			messages: initialMessages,
-			transport: createReattachingTransport(chatId, {
-				onSettled: () => reattachSettledRef.current(),
-				lastMessageId: () => reattachLastIdRef.current,
-			}),
+			transport: createReattachingTransport(
+				chatId,
+				{
+					onSettled: () => reattachSettledRef.current(),
+					lastMessageId: () => reattachLastIdRef.current,
+				},
+				{ takeInput },
+			),
 			// After the learner answers (addToolOutput), automatically send the
 			// continuation request so the teacher reacts to the answer.
 			sendAutomaticallyWhen: lastAssistantMessageIsCompleteWithToolCalls,
@@ -200,6 +220,7 @@ export function Chat({
 	useEffect(() => {
 		if (!sentInitial.current && initialPrompt && initialMessages.length === 0) {
 			sentInitial.current = true;
+			stashInput({ type: "text", text: initialPrompt });
 			void sendMessage({ text: initialPrompt });
 		}
 	}, [initialPrompt, initialMessages.length, sendMessage]);
@@ -343,6 +364,7 @@ export function Chat({
 			messages.length > 0 &&
 			lastAssistantMessageIsCompleteWithToolCalls({ messages })
 		) {
+			stashInput({ type: "continue" });
 			void sendMessage();
 		}
 		// mount-only by design (turnInFlight read at initial value)
@@ -492,6 +514,7 @@ export function Chat({
 			status === "ready" &&
 			lastAssistantMessageIsCompleteWithToolCalls({ messages: record.messages })
 		) {
+			stashInput({ type: "continue" });
 			void sendMessage();
 		}
 	}, [chatId, setMessages, sendMessage, status]);
@@ -612,8 +635,8 @@ export function Chat({
 			// TWO REAL MESSAGES, ONE TURN (the custom-message scheme, user-decided
 			// 2026-09-12): a typed note is the learner's own user message, and the
 			// verdict is its own custom message — marker part ONLY, no human-
-			// authored text (the model-facing wording lives in the adapter:
-			// record-adapter flattens it; nothing fake is persisted as speech).
+			// authored text (the model-facing wording lives in toLlmMessages,
+			// the native convertToLlm seam; nothing fake is persisted as speech).
 			// setMessages + sendMessage() (no args) fires ONE request carrying
 			// both — the same single-turn mechanism syncFromServer already uses,
 			// so no 409 dance and no double teacher turn.
@@ -639,6 +662,10 @@ export function Chat({
 				],
 			});
 			setMessages([...messages, ...appended]);
+			// The event (Wave B): the server appends the note (its own user
+			// message) + the verdict marker natively — the optimistic ids above
+			// are local render only; the settle sync lands the canon.
+			stashInput({ type: "verdict", accepted, note: note || undefined });
 			void sendMessage();
 		},
 		[text, messages, setMessages, sendMessage],
@@ -964,6 +991,7 @@ export function Chat({
 		if (!t || busy || pending) return;
 		draftRef.current = t; // the refusal flow's preserve-and-replay seam
 		setText("");
+		stashInput({ type: "text", text: t });
 		void sendMessage({ text: t });
 	};
 
@@ -972,7 +1000,10 @@ export function Chat({
 			value={{
 				chatId,
 				syncFromServer,
-				sendText: (t: string) => void sendMessage({ text: t }),
+				sendText: (t: string) => {
+					stashInput({ type: "text", text: t });
+					void sendMessage({ text: t });
+				},
 				openSetup: () => setSetupOpen(true),
 			}}
 		>
@@ -1318,6 +1349,7 @@ export function Chat({
 				if (t) {
 					setText("");
 					draftRef.current = t;
+					stashInput({ type: "text", text: t });
 					void sendMessage({ text: t });
 				}
 			}}