Wave A: pi-native tool layer — delete LhTool/toPiTool, TypeBox everywhere, terminate on questions

- src/agent/lh-tool.ts deleted: the zod-wrapped LhTool + toPiTool bridge
  (z.toJSONSchema per call, clientQuestion flag, hand-rolled result mapping)
  is gone. Tools are pi-agent-core native AgentTools now.
- New src/agent/tool-execute.ts owns what the wrapper added: the abort guard
  (runWithAbortGuard: run signal + 30s per-call timeout + 250ms grace,
  'Operation aborted' / timeout wording preserved), ToolInputError (the
  retryable '- problem at path' format), result mapping (string verbatim /
  object JSON / image parts, details rides the record's tool part output),
  and questionResult() — placeholder + terminate:true (owner Option A:
  belt of terminate + slim makeQuestionStopper with the clean-question
  rule; maxTurns deleted from the teaching turn entirely per owner).
- All 11 tool files + tools.ts registries converted to TypeBox parameters
  (typebox@1.3.7, pinned to pi-agent-core's copy). zod refinements
  (quizInputProblems, askOptionProblems, live-nodeId) moved from schemas
  into execute — the model sees the same retryable error shape.
- question-core + contracts/probe TypeBox-authored (single source shared
  with the UI); tool-parts parse seam runs the boundary's full chain
  (Convert → Check → Clean → refinement), fixing the live-smoke lockout:
  pi's boundary Value.Converts correctAnswer: 17 → '17' but the record
  keeps raw args, so a parse without Convert rejected a posed quiz
  (invisible pending question, turn ended). Pinned with the real smoke
  emission shape.
- Subagents converted: demo-builder/researcher AgentTool-native,
  visual-maker/pdf-reader declaration-only pi-ai Tools with local execute
  fns, extraction submit schemas re-authored in TypeBox (owner option 2:
  zod defaults → Type.Optional + fill at the submit seam).
- Accepted delta, flagged: TypeBox-native schemas skip pi's JSON-Schema
  primitive coercion fast path... (boundary still Value.Converts), and
  prober-quiz unknown keys ride through (Value.Clean strips at display).
- Tests: 988 passing (was 967 at the recon baseline); tool-abort and
  read-tool rewritten against the native seams; question-core/question-
  tools/tool-parts/demos/web-search/graph-tools/plan-tree/probe-done/
  tool-toggles converted to Value.Check/execute pins.

Live smoke (PORT=3004, real model): native ls turn streams end-to-end; a
real quiz pose (first attempt missing correctAnswer → tool-input-error →
model retry → posed) terminates the turn cleanly and persists pending.

src/agent/tools/jobs.ts

@@ -1,5 +1,6 @@
-import { z } from "zod";
-import { lhTool, type LhTool } from "../lh-tool.ts";
+import { Type, type Static } from "typebox";
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import { serverExecute } from "../tool-execute.ts";
 import type { JobRecord } from "../../core/contracts.ts";
 import type { JobStore } from "../../core/ports.ts";
 
@@ -30,43 +31,41 @@ export interface JobToolContext {
 	searchAvailable?: () => boolean;
 }
 
-export const researchInputSchema = z.object({
-	question: z
-		.string()
-		.describe("The single research question to answer. Make it specific — the researcher sees nothing else of the lesson."),
-	context: z
-		.string()
-		.optional()
-		.describe("Why you need this / what the lesson needs it for — focuses the brief. One or two sentences."),
+export const researchInputSchema = Type.Object({
+	question: Type.String({
+		description: "The single research question to answer. Make it specific — the researcher sees nothing else of the lesson.",
+	}),
+	context: Type.Optional(
+		Type.String({
+			description: "Why you need this / what the lesson needs it for — focuses the brief. One or two sentences.",
+		}),
+	),
 });
 
-export const demoInputSchema = z.object({
-	title: z.string().describe("Short title for the demo card, e.g. 'Damped harmonic oscillator'."),
-	brief: z
-		.string()
-		.describe(
+export const demoInputSchema = Type.Object({
+	title: Type.String({ description: "Short title for the demo card, e.g. 'Damped harmonic oscillator'." }),
+	brief: Type.String({
+		description:
 			"Precise brief for the builder: the concept, the parameters/controls and what each does, the interactions, and the visual style. " +
 			"The builder sees NOTHING else of the lesson — include everything it needs, including necessary formulas and constants.",
-		),
+	}),
 });
 
-export const visualInputSchema = z.object({
-	brief: z
-		.string()
-		.describe(
+export const visualInputSchema = Type.Object({
+	brief: Type.String({
+		description:
 			"Precise brief for ONE static figure: exactly what it must show — coordinates, labels, proportions, orientation. " +
 			"The maker sees NOTHING else of the lesson; a wrong or vague brief produces a wrong figure.",
-		),
+	}),
 });
 
-export const pdfInputSchema = z.object({
-	path: z.string().describe("Path to the learner's PDF (relative or absolute), exactly as they gave it."),
-	question: z
-		.string()
-		.describe(
+export const pdfInputSchema = Type.Object({
+	path: Type.String({ description: "Path to the learner's PDF (relative or absolute), exactly as they gave it." }),
+	question: Type.String({
+		description:
 			"What you need from the document — the specific content, explanation, or answer to extract and brief. " +
 			"The reader sees NOTHING else of the lesson.",
-		),
+	}),
 });
 
 /**
@@ -133,39 +132,47 @@ const PDF_DESCRIPTION =
  * server can't dispatch doomed research jobs. Jobs ALREADY in flight when
  * a key disappears still run to their honest failure (runner backstop).
  */
-export function jobTools(ctx: JobToolContext): Record<string, LhTool<any, any>> {
+export function jobTools(ctx: JobToolContext): Record<string, AgentTool<any>> {
 	const searchOn = ctx.searchAvailable?.() ?? true;
 	return {
 		...(searchOn && {
-			research: lhTool({
+			research: {
 				name: "research",
+				label: "research",
 				description: RESEARCH_DESCRIPTION,
-				schema: researchInputSchema,
-				execute: async (input, { toolCallId }) => dispatch(ctx, "research", toolCallId, RESEARCH_ACK, input),
-			}),
+				parameters: researchInputSchema,
+				execute: serverExecute("research", researchInputSchema, (input, { toolCallId }) =>
+					dispatch(ctx, "research", toolCallId, RESEARCH_ACK, input),
+				),
+			},
 		}),
-		demo: lhTool({
+		demo: {
 			name: "demo",
+			label: "demo",
 			description: DEMO_DESCRIPTION,
-			schema: demoInputSchema,
-			execute: async (input, { toolCallId }) => dispatch(ctx, "demo", toolCallId, DEMO_ACK, input),
-		}),
-		visual: lhTool({
+			parameters: demoInputSchema,
+			execute: serverExecute("demo", demoInputSchema, (input, { toolCallId }) => dispatch(ctx, "demo", toolCallId, DEMO_ACK, input)),
+		},
+		visual: {
 			name: "visual",
+			label: "visual",
 			description: VISUAL_DESCRIPTION,
-			schema: visualInputSchema,
-			execute: async (input, { toolCallId }) => dispatch(ctx, "visual", toolCallId, VISUAL_ACK, input),
-		}),
-		pdf: lhTool({
+			parameters: visualInputSchema,
+			execute: serverExecute("visual", visualInputSchema, (input, { toolCallId }) =>
+				dispatch(ctx, "visual", toolCallId, VISUAL_ACK, input),
+			),
+		},
+		pdf: {
 			name: "pdf",
+			label: "pdf",
 			description: PDF_DESCRIPTION,
-			schema: pdfInputSchema,
-			execute: async (input, { toolCallId }) => dispatch(ctx, "pdf", toolCallId, PDF_ACK, input),
-		}),
+			parameters: pdfInputSchema,
+			execute: serverExecute("pdf", pdfInputSchema, (input, { toolCallId }) => dispatch(ctx, "pdf", toolCallId, PDF_ACK, input)),
+		},
 	};
 }
 
-export type ResearchInput = z.infer<typeof researchInputSchema>;
-export type DemoInput = z.infer<typeof demoInputSchema>;
-export type VisualInput = z.infer<typeof visualInputSchema>;
-export type PdfInput = z.infer<typeof pdfInputSchema>;
+export type ResearchInput = Static<typeof researchInputSchema>;
+export type DemoInput = Static<typeof demoInputSchema>;
+export type VisualInput = Static<typeof visualInputSchema>;
+export type PdfInput = Static<typeof pdfInputSchema>;