@oh-my-pi/pi-coding-agent 15.0.2 → 15.1.1

package/src/tools/job.ts

@@ -2,7 +2,7 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { prompt } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import { type AsyncJob, AsyncJobManager, isBackgroundJobSupportEnabled } from "../async";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
@@ -22,28 +22,21 @@ import {
 } from "./render-utils";
 import { ToolError } from "./tool-errors";
 
-const jobSchema = Type.Object({
-	poll: Type.Optional(
-		Type.Array(Type.String(), {
-			description: "background job ids to wait for; omit (with no `cancel`) to wait on all running jobs",
-			examples: [["job-1234"]],
-		}),
-	),
-	cancel: Type.Optional(
-		Type.Array(Type.String(), {
-			description: "background job ids to cancel",
-			examples: [["job-1234"]],
-		}),
-	),
-	list: Type.Optional(
-		Type.Boolean({
-			description:
-				"Return an immediate snapshot of every job spawned by this agent (running + completed within retention). Read-only \u2014 cannot be combined with `poll` or `cancel`.",
-		}),
-	),
+const jobSchema = z.object({
+	poll: z
+		.array(z.string())
+		.optional()
+		.describe("background job ids to wait for; omit (with no `cancel`) to wait on all running jobs"),
+	cancel: z.array(z.string()).optional().describe("background job ids to cancel"),
+	list: z
+		.boolean()
+		.optional()
+		.describe(
+			"Return an immediate snapshot of every job spawned by this agent (running + completed within retention). Read-only \u2014 cannot be combined with `poll` or `cancel`.",
+		),
 });
 
-type JobParams = Static<typeof jobSchema>;
+type JobParams = z.infer<typeof jobSchema>;
 
 const WAIT_DURATION_MS: Record<string, number> = {
 	"5s": 5_000,

package/src/tools/read.ts

@@ -7,7 +7,7 @@ import { glob, type SummaryResult, summarizeCode } from "@oh-my-pi/pi-natives";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { getRemoteDir, logger, prompt, readImageMetadata, untilAborted } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import { getFileReadCache } from "../edit/file-read-cache";
 import { isNotebookPath, readEditableNotebookText } from "../edit/notebook";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
@@ -473,14 +473,13 @@ function prependSuffixResolutionNotice(text: string, suffixResolution?: { from:
 	return text ? `${notice}\n${text}` : notice;
 }
 
-const readSchema = Type.Object({
-	path: Type.String({
-		description: 'path or url; append :<sel> for line ranges or raw mode (e.g. "src/foo.ts:50-100")',
-		examples: ["src/foo.ts", "src/foo.ts:50-100", "https://example.com/:1-40"],
-	}),
-});
+const readSchema = z
+	.object({
+		path: z.string().describe('path or url; append :<sel> for line ranges or raw mode (e.g. "src/foo.ts:50-100")'),
+	})
+	.strict();
 
-export type ReadToolInput = Static<typeof readSchema>;
+export type ReadToolInput = z.infer<typeof readSchema>;
 
 export interface ReadToolDetails {
 	kind?: "file" | "url";

package/src/tools/recipe/index.ts

@@ -1,7 +1,7 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { prompt } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import type { RenderResultOptions } from "../../extensibility/custom-tools/types";
 import type { Theme } from "../../modes/theme/theme";
 import recipeDescription from "../../prompts/tools/recipe.md" with { type: "text" };
@@ -11,14 +11,12 @@ import { createRecipeToolRenderer, type RecipeRenderArgs } from "./render";
 import { buildPromptModel, type DetectedRunner, resolveCommand } from "./runner";
 import { RUNNERS } from "./runners";
 
-const recipeSchema = Type.Object({
-	op: Type.String({
-		description: 'task name and args, e.g. "test" or "build --release"',
-		examples: ["test", "build --release", "pkg:test --watch"],
-	}),
-});
-
-type RecipeParams = Static<typeof recipeSchema>;
+const recipeSchema = z
+	.object({
+		op: z.string().describe('task name and args, e.g. "test" or "build --release"'),
+	})
+	.strict();
+type RecipeParams = z.infer<typeof recipeSchema>;
 
 type RecipeRenderResult = {
 	content: Array<{ type: string; text?: string }>;

package/src/tools/render-mermaid.ts

@@ -1,22 +1,22 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { type MermaidAsciiRenderOptions, prompt, renderMermaidAscii } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import renderMermaidDescription from "../prompts/tools/render-mermaid.md" with { type: "text" };
 import type { ToolSession } from "./index";
 
-const renderMermaidSchema = Type.Object({
-	mermaid: Type.String({ description: "mermaid source", examples: ["graph TD; A-->B"] }),
-	config: Type.Optional(
-		Type.Object({
-			useAscii: Type.Optional(Type.Boolean()),
-			paddingX: Type.Optional(Type.Number()),
-			paddingY: Type.Optional(Type.Number()),
-			boxBorderPadding: Type.Optional(Type.Number()),
-		}),
-	),
+const renderMermaidSchema = z.object({
+	mermaid: z.string().describe("mermaid source"),
+	config: z
+		.object({
+			useAscii: z.boolean().optional(),
+			paddingX: z.number().optional(),
+			paddingY: z.number().optional(),
+			boxBorderPadding: z.number().optional(),
+		})
+		.optional(),
 });
 
-type RenderMermaidParams = Static<typeof renderMermaidSchema>;
+type RenderMermaidParams = z.infer<typeof renderMermaidSchema>;
 
 function sanitizeRenderConfig(config: MermaidAsciiRenderOptions | undefined): MermaidAsciiRenderOptions | undefined {
 	if (!config) return undefined;

package/src/tools/report-tool-issue.ts

@@ -9,13 +9,13 @@ import { Database } from "bun:sqlite";
 import path from "node:path";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import { $flag, getAgentDir, logger, VERSION } from "@oh-my-pi/pi-utils";
-import { Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import type { Settings } from "..";
 import type { ToolSession } from "./index";
 
-const ReportToolIssueParams = Type.Object({
-	tool: Type.String({ description: "tool name", examples: ["bash", "read"] }),
-	report: Type.String({ description: "unexpected behavior" }),
+const ReportToolIssueParams = z.object({
+	tool: z.string().describe("tool name"),
+	report: z.string().describe("unexpected behavior"),
 });
 
 export function isAutoQaEnabled(settings?: Settings): boolean {

package/src/tools/resolve.ts

@@ -2,7 +2,7 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import resolveDescription from "../prompts/tools/resolve.md" with { type: "text" };
@@ -11,18 +11,18 @@ import type { ToolSession } from ".";
 import { replaceTabs } from "./render-utils";
 import { ToolError } from "./tool-errors";
 
-const resolveSchema = Type.Object({
-	action: Type.Union([Type.Literal("apply"), Type.Literal("discard")]),
-	reason: Type.String({ description: "reason for action", examples: ["approved by user"] }),
-	extra: Type.Optional(
-		Type.Record(Type.String(), Type.Unknown(), {
-			description:
-				'Free-form metadata interpreted by the resolving tool (e.g. plan-mode approval requires `{ title: "<PLAN_TITLE>" }`).',
-		}),
-	),
+const resolveSchema = z.object({
+	action: z.union([z.literal("apply"), z.literal("discard")]),
+	reason: z.string().describe("reason for action"),
+	extra: z
+		.record(z.string(), z.unknown())
+		.optional()
+		.describe(
+			'Free-form metadata interpreted by the resolving tool (e.g. plan-mode approval requires `{ title: "<PLAN_TITLE>" }`).',
+		),
 });
 
-type ResolveParams = Static<typeof resolveSchema>;
+type ResolveParams = z.infer<typeof resolveSchema>;
 
 export interface ResolveToolDetails {
 	action: "apply" | "discard";

package/src/tools/review.ts

@@ -6,18 +6,15 @@
  * Reviewers finish via `yield` tool with SubmitReviewDetails schema.
  */
 // ─────────────────────────────────────────────────────────────────────────────
-// Subprocess tool handlers - registered for extraction/rendering in task tool
-// ─────────────────────────────────────────────────────────────────────────────
+
 import path from "node:path";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
-import { StringEnum } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Container, Text } from "@oh-my-pi/pi-tui";
 import { isRecord } from "@oh-my-pi/pi-utils";
-import { Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import type { Theme, ThemeColor } from "../modes/theme/theme";
 import { subprocessToolRegistry } from "../task/subprocess-tool-registry";
-
 export type FindingPriority = "P0" | "P1" | "P2" | "P3";
 
 export interface FindingPriorityInfo {
@@ -53,27 +50,18 @@ function getPriorityDisplay(
 }
 
 // report_finding schema
-const ReportFindingParams = Type.Object({
-	title: Type.String({
-		description: "prefixed imperative title",
-		examples: ["[P1] un-padding wrong dimension"],
-	}),
-	body: Type.String({
-		description: "problem explanation",
-	}),
-	priority: StringEnum(["P0", "P1", "P2", "P3"], {
-		description: "priority 0-3",
-	}),
-	confidence: Type.Number({
-		minimum: 0,
-		maximum: 1,
-		description: "confidence score",
-		examples: [0.0, 0.5, 1.0],
-	}),
-	file_path: Type.String({ description: "file path" }),
-	line_start: Type.Number({ description: "start line" }),
-	line_end: Type.Number({ description: "end line" }),
-});
+// report_finding schema
+const ReportFindingParams = z
+	.object({
+		title: z.string().describe("prefixed imperative title"),
+		body: z.string().describe("problem explanation"),
+		priority: z.enum(["P0", "P1", "P2", "P3"] as const).describe("priority 0-3"),
+		confidence: z.number().min(0).max(1).describe("confidence score"),
+		file_path: z.string().describe("file path"),
+		line_start: z.number().describe("start line"),
+		line_end: z.number().describe("end line"),
+	})
+	.strict();
 
 interface ReportFindingDetails {
 	title: string;

package/src/tools/search-tool-bm25.ts

@@ -1,7 +1,8 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import { type Component, Text } from "@oh-my-pi/pi-tui";
+import type { Component } from "@oh-my-pi/pi-tui";
+import { Text } from "@oh-my-pi/pi-tui";
 import { prompt } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import searchToolBm25Description from "../prompts/tools/search-tool-bm25.md" with { type: "text" };
@@ -30,15 +31,12 @@ const COLLAPSED_MATCH_LIMIT = 5;
 const MATCH_LABEL_LEN = 72;
 const MATCH_DESCRIPTION_LEN = 96;
 
-const searchToolBm25Schema = Type.Object({
-	query: Type.String({
-		description: "tool search query",
-		examples: ["kubernetes pod", "image processing", "git commit"],
-	}),
-	limit: Type.Optional(Type.Integer({ description: "max matches", minimum: 1 })),
+const searchToolBm25Schema = z.object({
+	query: z.string().describe("tool search query"),
+	limit: z.number().int().min(1).optional().describe("max matches"),
 });
 
-type SearchToolBm25Params = Static<typeof searchToolBm25Schema>;
+type SearchToolBm25Params = z.infer<typeof searchToolBm25Schema>;
 
 interface SearchToolBm25Match {
 	name: string;

package/src/tools/search.ts

@@ -1,11 +1,10 @@
 import * as path from "node:path";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-
 import { type GrepMatch, GrepOutputMode, type GrepResult, grep } from "@oh-my-pi/pi-natives";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import { getFileReadCache } from "../edit/file-read-cache";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
@@ -31,25 +30,23 @@ import {
 import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 
-const searchSchema = Type.Object({
-	pattern: Type.String({ description: "regex pattern", examples: ["function\\s+\\w+", "TODO"] }),
-	paths: Type.Array(Type.String({ description: "file, directory, glob, or internal URL to search" }), {
-		minItems: 1,
-		description: "files, directories, globs, or internal URLs to search",
-		examples: [["src/"], ["src/foo.ts"], ["src/**/*.ts"], ["src/", "packages/"]],
-	}),
-	i: Type.Optional(Type.Boolean({ description: "case-insensitive search", default: false })),
-	gitignore: Type.Optional(Type.Boolean({ description: "respect gitignore", default: true })),
-	skip: Type.Optional(
-		Type.Number({
-			description:
-				"files to skip before collecting results — use to paginate when the prior call hit the file limit",
-			default: 0,
-		}),
-	),
-});
-
-export type SearchToolInput = Static<typeof searchSchema>;
+const searchSchema = z
+	.object({
+		pattern: z.string().describe("regex pattern"),
+		paths: z
+			.array(z.string().describe("file, directory, glob, or internal URL to search"))
+			.min(1)
+			.describe("files, directories, globs, or internal URLs to search"),
+		i: z.boolean().optional().describe("case-insensitive search"),
+		gitignore: z.boolean().optional().describe("respect gitignore"),
+		skip: z
+			.number()
+			.optional()
+			.describe("files to skip before collecting results — use to paginate when the prior call hit the file limit"),
+	})
+	.strict();
+
+export type SearchToolInput = z.infer<typeof searchSchema>;
 
 /** Maximum number of distinct files surfaced in a single response. The
  * agent paginates further pages via `skip`. */
@@ -89,7 +86,7 @@ export interface SearchToolDetails {
 	missingPaths?: string[];
 }
 
-type SearchParams = Static<typeof searchSchema>;
+type SearchParams = z.infer<typeof searchSchema>;
 
 export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDetails> {
 	readonly name = "search";

package/src/tools/ssh.ts

@@ -2,7 +2,7 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { prompt } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import type { SSHHost } from "../capability/ssh";
 import { sshCapability } from "../capability/ssh";
 import { loadCapability } from "../discovery";
@@ -21,11 +21,11 @@ import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 import { clampTimeout } from "./tool-timeouts";
 
-const sshSchema = Type.Object({
-	host: Type.String({ description: "ssh host", examples: ["my-server", "prod-1"] }),
-	command: Type.String({ description: "remote command", examples: ["ls -la", "uptime"] }),
-	cwd: Type.Optional(Type.String({ description: "remote working directory", examples: ["/var/log"] })),
-	timeout: Type.Optional(Type.Number({ description: "timeout in seconds", default: 60 })),
+const sshSchema = z.object({
+	host: z.string().describe("ssh host"),
+	command: z.string().describe("remote command"),
+	cwd: z.string().optional().describe("remote working directory"),
+	timeout: z.number().optional().describe("timeout in seconds").default(60),
 });
 
 export interface SSHToolDetails {
@@ -116,7 +116,7 @@ async function loadHosts(session: ToolSession): Promise<{
 	return { hostNames, hostsByName };
 }
 
-type SshToolParams = Static<typeof sshSchema>;
+type SshToolParams = z.infer<typeof sshSchema>;
 
 export class SshTool implements AgentTool<typeof sshSchema, SSHToolDetails> {
 	readonly name = "ssh";

package/src/tools/todo-write.ts

@@ -1,10 +1,9 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import { StringEnum } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { prompt } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
 import chalk from "chalk";
+import * as z from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import todoWriteDescription from "../prompts/tools/todo-write.md" with { type: "text" };
@@ -45,45 +44,38 @@ export interface TodoWriteToolDetails {
 // Schema
 // =============================================================================
 
-const TodoOp = StringEnum(["init", "start", "done", "rm", "drop", "append", "note"] as const, {
-	description: "operation to apply",
-});
+const TodoOp = z
+	.enum(["init", "start", "done", "rm", "drop", "append", "note"] as const)
+	.describe("operation to apply");
 
-const InitListEntry = Type.Object({
-	phase: Type.String({ description: "phase name (short noun phrase)", examples: ["Foundation", "Auth"] }),
-	items: Type.Array(Type.String({ description: "task content (5-10 words)" }), {
-		minItems: 1,
-		description: "tasks for this phase, in execution order; all start as pending",
-	}),
+const InitListEntry = z.object({
+	phase: z.string().describe("phase name (short noun phrase)"),
+	items: z
+		.array(z.string().describe("task content (5-10 words)"))
+		.min(1)
+		.describe("tasks for this phase, in execution order; all start as pending"),
 });
 
-const TodoOpEntry = Type.Object({
+const TodoOpEntry = z.object({
 	op: TodoOp,
-	list: Type.Optional(Type.Array(InitListEntry, { description: "phased task list for op=init" })),
-	task: Type.Optional(
-		Type.String({ description: "task content for start/done/rm/drop/note", examples: ["Run tests"] }),
-	),
-	phase: Type.Optional(Type.String({ description: "phase name for done/rm/drop/append", examples: ["Auth"] })),
-	items: Type.Optional(
-		Type.Array(Type.String({ description: "task content (5-10 words)" }), {
-			minItems: 1,
-			description: "tasks to append to `phase` for op=append",
-		}),
-	),
-	text: Type.Optional(Type.String({ description: "note text for op=note (appended with newline)" })),
+	list: z.array(InitListEntry).optional().describe("phased task list for op=init"),
+	task: z.string().optional().describe("task content for start/done/rm/drop/note"),
+	phase: z.string().optional().describe("phase name for done/rm/drop/append"),
+	items: z
+		.array(z.string().describe("task content (5-10 words)"))
+		.min(1)
+		.optional()
+		.describe("tasks to append to `phase` for op=append"),
+	text: z.string().optional().describe("note text for op=note (appended with newline)"),
 });
 
-const todoWriteSchema = Type.Object(
-	{
-		ops: Type.Array(TodoOpEntry, {
-			minItems: 1,
-			description: "ordered todo operations",
-		}),
-	},
-	{ description: "Apply ordered todo operations" },
-);
+const todoWriteSchema = z
+	.object({
+		ops: z.array(TodoOpEntry).min(1).describe("ordered todo operations"),
+	})
+	.describe("Apply ordered todo operations");
 
-type TodoWriteParams = Static<typeof todoWriteSchema>;
+type TodoWriteParams = z.infer<typeof todoWriteSchema>;
 type TodoOpEntryValue = TodoWriteParams["ops"][number];
 
 // =============================================================================

package/src/tools/vim.ts

@@ -2,8 +2,8 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import type { Component } from "@oh-my-pi/pi-tui";
 import { extractSegments, sliceWithWidth, Text } from "@oh-my-pi/pi-tui";
 import { isEnoent, logger, prompt, untilAborted } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
 import * as Diff from "diff";
+import * as z from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { createLspWritethrough, type FileDiagnosticsResult, type WritethroughCallback, writethroughNoop } from "../lsp";
 import { getLanguageFromPath, highlightCode, type Theme } from "../modes/theme/theme";
@@ -36,35 +36,19 @@ import { toolResult } from "./tool-result";
 const INTERNAL_URL_PREFIX = /^(agent|artifact|skill|rule|local|mcp):\/\//;
 const utf8Decoder = new TextDecoder("utf-8", { fatal: true });
 
-const vimStepSchema = Type.Object({
-	kbd: Type.Array(Type.String(), {
-		description: "vim key sequences",
-		examples: [["ggdGi"], ["3Go"], ["dd"]],
-	}),
-	insert: Type.Optional(
-		Type.String({
-			description: "raw text to insert",
-			examples: ["hello world"],
-		}),
-	),
+const vimStepSchema = z.object({
+	kbd: z.array(z.string()).describe("vim key sequences"),
+	insert: z.string().optional().describe("raw text to insert"),
 });
 
-const vimSchema = Type.Object({
-	file: Type.String({ description: "file path", examples: ["src/foo.ts"] }),
-	steps: Type.Optional(
-		Type.Array(vimStepSchema, {
-			description: "editing steps",
-		}),
-	),
-	pause: Type.Optional(
-		Type.Boolean({
-			description: "skip auto-save",
-		}),
-	),
+const vimSchema = z.object({
+	file: z.string().describe("file path"),
+	steps: z.array(vimStepSchema).optional().describe("editing steps"),
+	pause: z.boolean().optional().describe("skip auto-save"),
 });
 
-type VimParams = Static<typeof vimSchema>;
-type VimStep = Static<typeof vimStepSchema>;
+type VimParams = z.infer<typeof vimSchema>;
+type VimStep = z.infer<typeof vimStepSchema>;
 
 interface VimRenderStep {
 	kbd?: string[];

package/src/tools/write.ts

@@ -5,7 +5,7 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { isEnoent, isRecord, prompt, untilAborted } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import { stripHashlinePrefixes } from "../edit";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { InternalUrlRouter } from "../internal-urls";
@@ -58,12 +58,12 @@ async function loadFflate(): Promise<typeof import("fflate")> {
 	return fflateModulePromise;
 }
 
-const writeSchema = Type.Object({
-	path: Type.String({ description: "file path", examples: ["src/new.ts"] }),
-	content: Type.String({ description: "file content" }),
+const writeSchema = z.object({
+	path: z.string().describe("file path"),
+	content: z.string().describe("file content"),
 });
 
-export type WriteToolInput = Static<typeof writeSchema>;
+export type WriteToolInput = z.infer<typeof writeSchema>;
 
 /** Details returned by the write tool for TUI rendering */
 export interface WriteToolDetails {