@oh-my-pi/pi-coding-agent 16.0.4 → 16.0.6

package/src/session/session-history-format.ts

@@ -45,6 +45,7 @@ const PRIMARY_ARG_KEYS = [
 	"query",
 	"prompt",
 	"assignment",
+	"note",
 	"message",
 	"op",
 	"name",
@@ -74,8 +75,16 @@ function lineCount(text: string): number {
 }
 
 /** Pick the most informative scalar argument of a tool call. */
-function primaryArg(args: Record<string, unknown> | undefined): string {
+function primaryArg(name: string, args: Record<string, unknown> | undefined): string {
 	if (!args || typeof args !== "object") return "";
+	// Advisor note is the most informative summary; preserve severity too.
+	if (name === "advise") {
+		const note = typeof args.note === "string" ? args.note : "";
+		const severity = typeof args.severity === "string" ? args.severity : "";
+		if (note && severity) return oneLine(`${severity}: ${note}`);
+		if (note) return oneLine(note);
+		if (severity) return oneLine(severity);
+	}
 	for (const key of PRIMARY_ARG_KEYS) {
 		const value = args[key];
 		if (typeof value === "string" && value.length > 0) return oneLine(value);
@@ -108,7 +117,7 @@ function toolCallLine(
 	result: ToolResultMessage | undefined,
 	includeToolIntent?: boolean,
 ): string {
-	const head = `→ ${name}(${primaryArg(args)})`;
+	const head = `→ ${name}(${primaryArg(name, args)})`;
 	let base: string;
 	if (!result) {
 		base = `${head} ⇒ pending`;

package/src/session/session-loader.ts

@@ -4,7 +4,7 @@ import { BlobStore, isBlobRef, resolveImageData, resolveImageDataUrl } from "./b
 import { buildSessionContext } from "./session-context";
 import type { FileEntry, SessionEntry, SessionHeader } from "./session-entries";
 import { migrateToCurrentVersion } from "./session-migrations";
-import { isImageBlock } from "./session-persistence";
+import { isImageBlock, isImageDataPayload } from "./session-persistence";
 import { FileSessionStorage, type SessionStorage } from "./session-storage";
 
 /** Exported for compaction.test.ts */
@@ -44,9 +44,19 @@ function hasImageUrl(value: unknown): value is { image_url: string } {
 	return typeof value === "object" && value !== null && "image_url" in value && typeof value.image_url === "string";
 }
 
-async function resolvePersistedImageUrlRefs(value: unknown, blobStore: BlobStore): Promise<void> {
+function shouldResolveImagePayload(value: unknown, key: string | undefined): value is { data: string } {
+	if (!isImageDataPayload(value) || !isBlobRef(value.data)) return false;
+	return (key === "content" && isImageBlock(value)) || key === "images";
+}
+
+async function resolvePersistedBlobRefs(value: unknown, blobStore: BlobStore, key?: string): Promise<void> {
+	if (shouldResolveImagePayload(value, key)) {
+		value.data = await resolveImageData(blobStore, value.data);
+		return;
+	}
+
 	if (Array.isArray(value)) {
-		await Promise.all(value.map(item => resolvePersistedImageUrlRefs(item, blobStore)));
+		await Promise.all(value.map(item => resolvePersistedBlobRefs(item, blobStore, key)));
 		return;
 	}
 
@@ -56,38 +66,15 @@ async function resolvePersistedImageUrlRefs(value: unknown, blobStore: BlobStore
 		value.image_url = await resolveImageDataUrl(blobStore, value.image_url);
 	}
 
-	await Promise.all(Object.values(value).map(item => resolvePersistedImageUrlRefs(item, blobStore)));
+	await Promise.all(
+		Object.entries(value).map(([childKey, item]) => resolvePersistedBlobRefs(item, blobStore, childKey)),
+	);
 }
 
 export async function resolveBlobRefsInEntries(entries: FileEntry[], blobStore: BlobStore): Promise<void> {
-	const promises: Promise<void>[] = [];
-
-	for (const entry of entries) {
-		if (entry.type === "session") continue;
-
-		let contentArray: unknown[] | undefined;
-		if (entry.type === "message" && "content" in entry.message && Array.isArray(entry.message.content)) {
-			contentArray = entry.message.content;
-		} else if (entry.type === "custom_message" && Array.isArray(entry.content)) {
-			contentArray = entry.content;
-		}
-
-		if (contentArray) {
-			for (const block of contentArray) {
-				if (isImageBlock(block) && isBlobRef(block.data)) {
-					promises.push(
-						resolveImageData(blobStore, block.data).then(resolved => {
-							block.data = resolved;
-						}),
-					);
-				}
-			}
-		}
-
-		promises.push(resolvePersistedImageUrlRefs(entry, blobStore));
-	}
-
-	await Promise.all(promises);
+	await Promise.all(
+		entries.filter(entry => entry.type !== "session").map(entry => resolvePersistedBlobRefs(entry, blobStore)),
+	);
 }
 
 /**

package/src/session/session-persistence.ts

@@ -36,10 +36,33 @@ export function isImageBlock(value: unknown): value is { type: "image"; data: st
 	);
 }
 
+function isImageMimeType(value: unknown): value is string {
+	return typeof value === "string" && value.toLowerCase().startsWith("image/");
+}
+
+export function isImageDataPayload(value: unknown): value is { data: string; mimeType?: string } {
+	return (
+		typeof value === "object" &&
+		value !== null &&
+		"data" in value &&
+		typeof (value as { data?: string }).data === "string" &&
+		(isImageBlock(value) || ("mimeType" in value && isImageMimeType((value as { mimeType?: unknown }).mimeType)))
+	);
+}
+
+function shouldExternalizeImagePayload(
+	value: unknown,
+	key: string | undefined,
+): value is { data: string; mimeType?: string } {
+	if (!isImageDataPayload(value)) return false;
+	if (isBlobRef(value.data) || value.data.length < BLOB_EXTERNALIZE_THRESHOLD) return false;
+	return (key === TEXT_CONTENT_KEY && isImageBlock(value)) || key === "images";
+}
+
 /**
  * Recursively truncate large strings in an object for session persistence.
  * - Truncates any oversized string fields (key-agnostic)
- * - Replaces oversized image blocks with text notices
+ * - Externalizes oversized image payloads to blob refs
  * - Updates lineCount when content is truncated
  * - Returns original object if no changes needed (structural sharing)
  *
@@ -50,6 +73,9 @@ export function isImageBlock(value: unknown): value is { type: "image"; data: st
  */
 function truncateForPersistence(obj: unknown, blobStore: BlobStore, key?: string): unknown {
 	if (obj === null || obj === undefined) return obj;
+	if (shouldExternalizeImagePayload(obj, key)) {
+		return { ...obj, data: externalizeImageDataSync(blobStore, obj.data, obj.mimeType) };
+	}
 
 	if (typeof obj === "string") {
 		if (key === "image_url" && isImageDataUrl(obj)) {
@@ -72,16 +98,6 @@ function truncateForPersistence(obj: unknown, blobStore: BlobStore, key?: string
 		const result: unknown[] = new Array(obj.length);
 		for (let i = 0; i < obj.length; i++) {
 			const item = obj[i];
-			if (
-				key === TEXT_CONTENT_KEY &&
-				isImageBlock(item) &&
-				!isBlobRef(item.data) &&
-				item.data.length >= BLOB_EXTERNALIZE_THRESHOLD
-			) {
-				changed = true;
-				result[i] = { ...item, data: externalizeImageDataSync(blobStore, item.data, item.mimeType) };
-				continue;
-			}
 			const newItem = truncateForPersistence(item, blobStore, key);
 			if (newItem !== item) changed = true;
 			result[i] = newItem;

package/src/session/snapcompact-inline.ts

@@ -14,8 +14,8 @@
  * estimate (`estimateInlineSavings`) so the two can never disagree.
  */
 
+import { countTokens } from "@oh-my-pi/pi-agent-core";
 import type { Context, ImageContent, Model, TextContent, ToolResultMessage, UserMessage } from "@oh-my-pi/pi-ai";
-import { countTokens } from "@oh-my-pi/pi-natives";
 import * as snapcompact from "@oh-my-pi/snapcompact";
 import contextFramesNote from "../prompts/system/snapcompact-context-frames-note.md" with { type: "text" };
 import contextStub from "../prompts/system/snapcompact-context-stub.md" with { type: "text" };

package/src/slash-commands/builtin-registry.ts

@@ -240,13 +240,8 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 		allowArgs: true,
 		handleTui: async (command, runtime) => {
 			const hadArgs = !!command.args;
-			// Capture state BEFORE the call: when plan mode is already active,
-			// handlePlanModeCommand may exit it (on confirmed exit) or leave it on (on cancel
-			// or warning). In every "already active" case the typed args are NOT consumed,
-			// so preserve them in history regardless of the user's confirm/cancel choice.
-			const wasPlanModeEnabled = runtime.ctx.planModeEnabled;
 			await runtime.ctx.handlePlanModeCommand(command.args || undefined);
-			if (hadArgs && wasPlanModeEnabled) {
+			if (hadArgs) {
 				runtime.ctx.editor.addToHistory(command.text);
 			}
 			runtime.ctx.editor.setText("");
@@ -275,10 +270,8 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 		allowArgs: true,
 		handleTui: async (command, runtime) => {
 			const hadArgs = !!command.args;
-			// Capture state BEFORE the call (see /plan above for rationale).
-			const wasGoalModeEnabled = runtime.ctx.goalModeEnabled;
 			await runtime.ctx.handleGoalModeCommand(command.args || undefined);
-			if (hadArgs && wasGoalModeEnabled) {
+			if (hadArgs) {
 				runtime.ctx.editor.addToHistory(command.text);
 			}
 			runtime.ctx.editor.setText("");
@@ -308,7 +301,7 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 	{
 		name: "model",
 		aliases: ["models"],
-		description: "Select model (opens selector UI)",
+		description: "Switch model for this session",
 		acpDescription: "Show current model selection",
 		handle: async (command, runtime) => {
 			if (command.args) {
@@ -341,7 +334,7 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			return commandConsumed();
 		},
 		handleTui: (_command, runtime) => {
-			runtime.ctx.showModelSelector();
+			runtime.ctx.showModelSelector({ temporaryOnly: true });
 			runtime.ctx.editor.setText("");
 		},
 	},

package/src/ssh/connection-manager.ts

@@ -65,7 +65,7 @@ async function deleteHostInfoFromDisk(hostName: string): Promise<void> {
 	}
 }
 
-async function validateKeyPermissions(keyPath?: string): Promise<void> {
+async function validateKeyPermissions(keyPath?: string, platform: SshPlatform = process.platform): Promise<void> {
 	if (!keyPath) return;
 	let stats: fs.Stats;
 	try {
@@ -79,6 +79,7 @@ async function validateKeyPermissions(keyPath?: string): Promise<void> {
 	if (!stats.isFile()) {
 		throw new Error(`SSH key is not a file: ${keyPath}`);
 	}
+	if (platform === "win32") return;
 	const mode = stats.mode & 0o777;
 	if ((mode & 0o077) !== 0) {
 		throw new Error(`SSH key permissions must be 600 or stricter: ${keyPath}`);
@@ -402,7 +403,7 @@ export async function buildRemoteCommand(
 	command: string,
 	options?: SSHArgsOptions,
 ): Promise<string[]> {
-	await validateKeyPermissions(host.keyPath);
+	await validateKeyPermissions(host.keyPath, options?.platform);
 	return [...buildCommonArgs(host, options), buildSshTarget(host.username, host.host), command];
 }
 

package/src/startup-splash.ts

@@ -0,0 +1,19 @@
+/** Inputs used to decide whether the optional startup splash may run for this process. */
+export interface StartupSplashDecisionOptions {
+	readonly configured: boolean;
+	readonly isInteractive: boolean;
+	readonly resuming: boolean;
+	readonly quiet: boolean;
+	readonly timing: boolean;
+	readonly stdinIsTTY: boolean | undefined;
+	readonly stdoutIsTTY: boolean | undefined;
+}
+
+/** Returns true only for explicitly enabled, normal interactive TTY startup. */
+export function shouldShowStartupSplash(options: StartupSplashDecisionOptions): boolean {
+	if (!options.configured) return false;
+	if (!options.isInteractive) return false;
+	if (options.resuming || options.quiet) return false;
+	if (options.timing) return false;
+	return options.stdinIsTTY === true && options.stdoutIsTTY === true;
+}

package/src/task/executor.ts

@@ -516,6 +516,7 @@ export function finalizeSubprocessOutput(args: FinalizeSubprocessOutputArgs): Fi
 	const { yieldItems, reportFindings, doneAborted, signalAborted, outputSchema } = args;
 	let abortedViaYield = false;
 	const hasYield = Array.isArray(yieldItems) && yieldItems.length > 0;
+	const hadFailureBeforeYield = exitCode !== 0 && stderr.trim().length > 0;
 
 	if (hasYield) {
 		const lastYield = yieldItems[yieldItems.length - 1];
@@ -553,12 +554,16 @@ export function finalizeSubprocessOutput(args: FinalizeSubprocessOutputArgs): Fi
 						const errorMessage = err instanceof Error ? err.message : String(err);
 						rawOutput = `{"error":"Failed to serialize yield data: ${errorMessage}"}`;
 					}
-					exitCode = 0;
-					stderr = overridden
-						? SUBAGENT_WARNING_SCHEMA_OVERRIDDEN
-						: schemaError
-							? `invalid output schema: ${schemaError}`
-							: "";
+					if (!hadFailureBeforeYield) {
+						exitCode = 0;
+						stderr = overridden
+							? SUBAGENT_WARNING_SCHEMA_OVERRIDDEN
+							: schemaError
+								? `invalid output schema: ${schemaError}`
+								: "";
+					} else if (!stderr) {
+						stderr = "Subagent failed after yielding a result.";
+					}
 				}
 			}
 		}
@@ -2117,8 +2122,8 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				void session.abort();
 			}
 
+			const pendingExtensionMessages: Array<Promise<unknown>> = [];
 			const extensionRunner = session.extensionRunner;
-			const pendingExtensionMessages: Promise<unknown>[] = [];
 			if (extensionRunner) {
 				extensionRunner.initialize(
 					{

package/src/task/types.ts

@@ -1,7 +1,7 @@
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Usage } from "@oh-my-pi/pi-ai";
 import { $env } from "@oh-my-pi/pi-utils";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import type { AgentSessionEvent } from "../session/agent-session";
 import type { NestedRepoPatch } from "./worktree";
 
@@ -78,37 +78,23 @@ export interface SubagentLifecyclePayload {
 export const ROLE_LABEL_MAX = 80;
 /** Schema bound on the raw `role` input, before it is label-normalized at every use site. */
 export const ROLE_INPUT_MAX = 256;
+const ROLE_INPUT_SCHEMA = `string <= ${ROLE_INPUT_MAX}` as const;
 
-/**
- * One unit of work. The single-spawn schema is `{ agent, ...taskItemSchema }`;
- * the batch schema (`task.batch`) is `{ agent, context, tasks: taskItemSchema[] }`.
- * When task isolation is enabled, `isolated` joins the item shape (per-item in
- * batch form, top-level in the flat form via the spread).
- */
-const taskItemShape = {
-	id: z.string().max(48).optional().describe("stable agent id; default generated"),
-	description: z.string().optional().describe("ui label, not seen by subagent"),
-	role: z
-		.string()
-		.max(ROLE_INPUT_MAX)
-		.optional()
-		.describe(
-			"specialist role/expertise this subagent embodies (e.g. 'Rust async-runtime specialist'); shapes its identity and display name",
-		),
-	assignment: z.string().describe("the work; self-contained instructions"),
-};
-const isolatedShape = {
-	isolated: z.boolean().optional().describe("run in isolated env; returns patches"),
-};
-const agentShape = {
-	agent: z.string().describe("agent type to spawn"),
-};
-const contextShape = {
-	context: z.string().describe("shared background prepended to each assignment"),
-};
-
-export const taskItemSchema = z.object(taskItemShape);
-const taskItemSchemaIsolated = z.object({ ...taskItemShape, ...isolatedShape });
+export const taskItemSchema = type({
+	"id?": "string",
+	"description?": "string",
+	"role?": ROLE_INPUT_SCHEMA,
+	assignment: "string",
+	"+": "delete",
+});
+const taskItemSchemaIsolated = type({
+	"id?": "string",
+	"description?": "string",
+	"role?": ROLE_INPUT_SCHEMA,
+	assignment: "string",
+	"isolated?": "boolean",
+	"+": "delete",
+});
 
 /** Single task item. Fields are optional defensively: args stream in token by token. */
 export interface TaskItem {
@@ -124,17 +110,34 @@ export interface TaskItem {
 	isolated?: boolean;
 }
 
-export const taskSchema = z.object({ ...agentShape, ...taskItemShape, ...isolatedShape });
-const taskSchemaNoIsolation = z.object({ ...agentShape, ...taskItemShape });
-const taskSchemaBatch = z.object({
-	...agentShape,
-	...contextShape,
-	tasks: z.array(taskItemSchemaIsolated).describe("tasks to spawn; one subagent per item"),
+export const taskSchema = type({
+	agent: "string",
+	"id?": "string",
+	"description?": "string",
+	"role?": ROLE_INPUT_SCHEMA,
+	assignment: "string",
+	"isolated?": "boolean",
+	"+": "delete",
+});
+const taskSchemaNoIsolation = type({
+	agent: "string",
+	"id?": "string",
+	"description?": "string",
+	"role?": ROLE_INPUT_SCHEMA,
+	assignment: "string",
+	"+": "delete",
+});
+const taskSchemaBatch = type({
+	agent: "string",
+	context: "string",
+	tasks: taskItemSchemaIsolated.array(),
+	"+": "delete",
 });
-const taskSchemaBatchNoIsolation = z.object({
-	...agentShape,
-	...contextShape,
-	tasks: z.array(taskItemSchema).describe("tasks to spawn; one subagent per item"),
+const taskSchemaBatchNoIsolation = type({
+	agent: "string",
+	context: "string",
+	tasks: taskItemSchema.array(),
+	"+": "delete",
 });
 const ALL_TASK_SCHEMAS = [taskSchema, taskSchemaNoIsolation, taskSchemaBatch, taskSchemaBatchNoIsolation] as const;
 

package/src/tool-discovery/tool-index.ts

@@ -1,5 +1,6 @@
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
-import { isZodSchema, zodToWireSchema } from "@oh-my-pi/pi-ai/utils/schema";
+import type { Tool as AiTool } from "@oh-my-pi/pi-ai";
+import { toolWireSchema } from "@oh-my-pi/pi-ai/utils/schema";
 
 // ─── Generic Tool Discovery Types ────────────────────────────────────────────
 
@@ -65,8 +66,13 @@ export function isMCPToolName(name: string): boolean {
 	return name.startsWith("mcp__");
 }
 
-function getSchemaPropertyKeys(parameters: unknown): string[] {
-	if (isZodSchema(parameters)) parameters = zodToWireSchema(parameters);
+function getSchemaPropertyKeys(tool: Pick<AiTool, "name" | "description" | "parameters">): string[] {
+	let parameters: unknown = tool.parameters;
+	try {
+		parameters = toolWireSchema(tool as AiTool);
+	} catch {
+		// Schema may contain functions or cycles; fall back to the raw shape.
+	}
 	if (!parameters || typeof parameters !== "object" || Array.isArray(parameters)) return [];
 	const properties = (parameters as { properties?: unknown }).properties;
 	if (!properties || typeof properties !== "object" || Array.isArray(properties)) return [];
@@ -149,7 +155,14 @@ export function getDiscoverableTool(
 		source,
 		serverName: typeof toolRecord.mcpServerName === "string" ? toolRecord.mcpServerName : undefined,
 		mcpToolName: typeof toolRecord.mcpToolName === "string" ? toolRecord.mcpToolName : undefined,
-		schemaKeys: getSchemaPropertyKeys(toolRecord.parameters),
+		schemaKeys:
+			toolRecord.parameters === undefined
+				? []
+				: getSchemaPropertyKeys({
+						name: tool.name,
+						description: rawDescription,
+						parameters: toolRecord.parameters as AiTool["parameters"],
+					}),
 	};
 }
 

package/src/tools/ask.ts

@@ -19,7 +19,7 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import type { ToolExample } from "@oh-my-pi/pi-ai";
 import { type Component, Markdown, type MarkdownTheme, renderInlineMarkdown, TERMINAL, Text } from "@oh-my-pi/pi-tui";
 import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
-import { z } from "zod/v4";
+import { type as arkType } from "arktype";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { ExtensionUISelectItem } from "../extensibility/extensions";
 import { getMarkdownTheme, type Theme, theme } from "../modes/theme/theme";
@@ -34,24 +34,24 @@ import { ToolAbortError } from "./tool-errors";
 // Types
 // =============================================================================
 
-const OptionItem = z.object({
-	label: z.string().describe("display label"),
-	description: z.string().describe("optional explanatory text displayed below the label").optional(),
+const OptionItem = arkType({
+	label: arkType("string").describe("display label"),
+	"description?": arkType("string").describe("optional explanatory text displayed below the label"),
 });
 
-const QuestionItem = z.object({
-	id: z.string().describe("question id"),
-	question: z.string().describe("question text"),
-	options: z.array(OptionItem).describe("available options"),
-	multi: z.boolean().describe("allow multiple selections").optional(),
-	recommended: z.number().describe("recommended option index").optional(),
+const QuestionItem = arkType({
+	id: arkType("string").describe("question id"),
+	question: arkType("string").describe("question text"),
+	options: OptionItem.array().describe("available options"),
+	"multi?": arkType("boolean").describe("allow multiple selections"),
+	"recommended?": arkType("number").describe("recommended option index"),
 });
 
-const askSchema = z.object({
-	questions: z.array(QuestionItem).min(1).describe("questions to ask"),
+const askSchema = arkType({
+	questions: QuestionItem.array().atLeastLength(1).describe("questions to ask"),
 });
 
-export type AskToolInput = z.infer<typeof askSchema>;
+export type AskToolInput = typeof askSchema.infer;
 
 /** Result for a single question */
 export interface QuestionResult {
@@ -424,7 +424,7 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 	readonly parameters = askSchema;
 	readonly strict = true;
 
-	readonly examples: readonly ToolExample<z.input<typeof askSchema>>[] = [
+	readonly examples: readonly ToolExample<typeof askSchema.infer>[] = [
 		{
 			caption: "Single question",
 			call: {

package/src/tools/ast-edit.ts

@@ -6,7 +6,7 @@ import { type AstReplaceChange, type AstReplaceFileChange, astEdit } from "@oh-m
 import type { Component } from "@oh-my-pi/pi-tui";
 import { replaceTabs, Text } from "@oh-my-pi/pi-tui";
 import { $envpos, prompt, untilAborted } from "@oh-my-pi/pi-utils";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import { canonicalSnapshotKey, getFileSnapshotStore } from "../edit/file-snapshot-store";
 import { normalizeToLF } from "../edit/normalize";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
@@ -35,16 +35,17 @@ import { queueResolveHandler } from "./resolve";
 import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 
-const astEditOpSchema = z.object({
-	pat: z.string().describe("ast pattern"),
-	out: z.string().describe("replacement template"),
+const astEditOpSchema = type({
+	pat: type("string").describe("ast pattern"),
+	out: type("string").describe("replacement template"),
 });
 
-const astEditSchema = z.object({
-	ops: z.array(astEditOpSchema).min(1).describe("rewrite ops"),
-	paths: z
-		.array(z.string().describe("file, directory, glob, or internal URL to rewrite"))
-		.min(1)
+const astEditSchema = type({
+	ops: astEditOpSchema.array().atLeastLength(1).describe("rewrite ops"),
+	paths: type("string")
+		.describe("file, directory, glob, or internal URL to rewrite")
+		.array()
+		.atLeastLength(1)
 		.describe("files, directories, globs, or internal URLs to rewrite"),
 });
 
@@ -165,16 +166,18 @@ export interface AstEditToolDetails {
 	cwd?: string;
 }
 
+type AstEditSchemaInfer = typeof astEditSchema.infer;
+
 export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolDetails> {
 	readonly name = "ast_edit";
 	readonly approval = (args: unknown) => {
-		const paths = Array.isArray((args as Partial<z.infer<typeof astEditSchema>>).paths)
-			? ((args as Partial<z.infer<typeof astEditSchema>>).paths as string[])
+		const paths = Array.isArray((args as Partial<AstEditSchemaInfer>).paths)
+			? ((args as Partial<AstEditSchemaInfer>).paths as string[])
 			: [];
 		return paths.length > 0 && paths.every(path => isInternalUrlPath(path)) ? "read" : "write";
 	};
 	readonly formatApprovalDetails = (args: unknown): string[] => {
-		const params = args as Partial<z.infer<typeof astEditSchema>>;
+		const params = args as Partial<AstEditSchemaInfer>;
 		const lines: string[] = [];
 		const ops = Array.isArray(params.ops) ? params.ops : [];
 		const firstOp = ops[0];
@@ -196,7 +199,7 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 	readonly parameters = astEditSchema;
 	readonly strict = true;
 
-	readonly examples: readonly ToolExample<z.input<typeof astEditSchema>>[] = [
+	readonly examples: readonly ToolExample<AstEditSchemaInfer>[] = [
 		{
 			caption: "Rename a call site across TypeScript files",
 			call: {
@@ -248,7 +251,7 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 
 	async execute(
 		_toolCallId: string,
-		params: z.infer<typeof astEditSchema>,
+		params: AstEditSchemaInfer,
 		signal?: AbortSignal,
 		_onUpdate?: AgentToolUpdateCallback<AstEditToolDetails>,
 		_context?: AgentToolContext,

package/src/tools/ast-grep.ts

@@ -6,7 +6,7 @@ import { type AstFindMatch, astGrep } 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 { z } from "zod/v4";
+import { type } from "arktype";
 import { recordFileSnapshot, recordSeenLinesFromBody } from "../edit/file-snapshot-store";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
@@ -34,13 +34,14 @@ import {
 import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 
-const astGrepSchema = z.object({
-	pat: z.string().describe("ast pattern"),
-	paths: z
-		.array(z.string().describe("file, directory, glob, or internal URL to search"))
-		.min(1)
+const astGrepSchema = type({
+	pat: type("string").describe("ast pattern"),
+	paths: type("string")
+		.describe("file, directory, glob, or internal URL to search")
+		.array()
+		.atLeastLength(1)
 		.describe("files, directories, globs, or internal URLs to search"),
-	skip: z.number().default(0).describe("matches to skip").optional(),
+	"skip?": type("number").describe("matches to skip"),
 });
 
 async function runMultiTargetAstGrep(
@@ -132,7 +133,7 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 	readonly parameters = astGrepSchema;
 	readonly strict = true;
 
-	readonly examples: readonly ToolExample<z.input<typeof astGrepSchema>>[] = [
+	readonly examples: readonly ToolExample<typeof astGrepSchema.inferIn>[] = [
 		{
 			caption: "Search TypeScript files under src",
 			call: { pat: "console.log($$$)", paths: ["src/**/*.ts"] },
@@ -162,7 +163,7 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 
 	async execute(
 		_toolCallId: string,
-		params: z.infer<typeof astGrepSchema>,
+		params: typeof astGrepSchema.infer,
 		signal?: AbortSignal,
 		_onUpdate?: AgentToolUpdateCallback<AstGrepToolDetails>,
 		_context?: AgentToolContext,