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

package/src/edit/hashline/params.ts

@@ -1,18 +1,19 @@
 /**
- * Zod schema for the `edit` tool's hashline mode payload. The schema is
- * deliberately permissive (`.passthrough()`) so providers can attach extra
+ * Arktype schema for the `edit` tool's hashline mode payload. The schema is
+ * deliberately permissive (allows extra keys) so providers can attach extra
  * keys without rejection; only `input` is required. `_input` is accepted as a
  * provider-emitted alias for `input`.
  */
-import { z } from "zod/v4";
+import { type } from "arktype";
 
-export const hashlineEditParamsSchema = z.preprocess(raw => {
-	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return raw;
+const requiredInputSchema = type({ input: "string" });
+const inputAliasSchema = type({ "input?": "string", "_input?": "string" });
 
-	const record = raw as Record<string, unknown>;
-	if (typeof record.input === "string" || typeof record._input !== "string") return raw;
+export const hashlineEditParamsSchema = inputAliasSchema
+	.pipe(raw => {
+		if (raw.input !== undefined || raw._input === undefined) return raw;
+		return { ...raw, input: raw._input };
+	})
+	.pipe(requiredInputSchema);
 
-	return { ...record, input: record._input };
-}, z.object({ input: z.string() }).passthrough());
-
-export type HashlineParams = z.infer<typeof hashlineEditParamsSchema>;
+export type HashlineParams = Parameters<typeof hashlineEditParamsSchema.assert>[0];

package/src/edit/index.ts

@@ -4,7 +4,6 @@ import hashlineDescription from "@oh-my-pi/hashline/prompt.md" with { type: "tex
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { ToolExample } from "@oh-my-pi/pi-ai";
 import { prompt } from "@oh-my-pi/pi-utils";
-import type { z } from "zod/v4";
 import {
 	createLspWritethrough,
 	type FileDiagnosticsResult,
@@ -20,7 +19,7 @@ import type { DeferredDiagnosticsEntry, ToolSession } from "../tools";
 import { truncateForPrompt } from "../tools/approval";
 import { isInternalUrlPath } from "../tools/path-utils";
 import { type EditMode, normalizeEditMode, resolveEditMode } from "../utils/edit-mode";
-import { executeHashlineSingle, type HashlineParams, hashlineEditParamsSchema } from "./hashline";
+import { executeHashlineSingle, hashlineEditParamsSchema } from "./hashline";
 import { type ApplyPatchParams, applyPatchSchema, expandApplyPatchToEntries } from "./modes/apply-patch";
 import applyPatchGrammar from "./modes/apply-patch.lark" with { type: "text" };
 import { executePatchSingle, type PatchEditEntry, type PatchParams, patchEditSchema } from "./modes/patch";
@@ -47,6 +46,8 @@ type TInput =
 	| typeof hashlineEditParamsSchema
 	| typeof applyPatchSchema;
 
+type HashlineParams = typeof hashlineEditParamsSchema.infer;
+
 type EditParams = ReplaceParams | PatchParams | HashlineParams | ApplyPatchParams;
 
 type EditModeDefinition = {
@@ -443,7 +444,7 @@ export class EditTool implements AgentTool<TInput> {
 						caption: "Multiple entries",
 						note: "All entries in one call apply to the top-level `path`; use separate calls for different files.",
 					},
-				] satisfies readonly ToolExample<z.input<typeof patchEditSchema>>[],
+				] satisfies readonly ToolExample<PatchParams>[],
 				execute: (
 					tool: EditTool,
 					params: EditParams,
@@ -479,7 +480,7 @@ export class EditTool implements AgentTool<TInput> {
 							input: '*** Begin Patch\n*** Add File: hello.txt\n+Hello world\n*** Update File: src/app.py\n*** Move to: src/main.py\n@@ def greet():\n-print("Hi")\n+print("Hello, world!")\n*** Delete File: obsolete.txt\n*** End Patch\n',
 						},
 					},
-				] satisfies readonly ToolExample<z.input<typeof applyPatchSchema>>[],
+				] satisfies readonly ToolExample<ApplyPatchParams>[],
 				execute: (
 					tool: EditTool,
 					params: EditParams,

package/src/edit/modes/apply-patch.ts

@@ -8,16 +8,16 @@
  * the `patch` mode.
  */
 
-import { z } from "zod/v4";
+import { type } from "arktype";
 import { parseApplyPatch, parseApplyPatchStreaming } from "../apply-patch/parser";
 import { ApplyPatchError } from "../diff";
 import type { PatchEditEntry } from "./patch";
 
-export const applyPatchSchema = z.object({
-	input: z.string().describe("apply_patch envelope"),
+export const applyPatchSchema = type({
+	input: "string",
 });
 
-export type ApplyPatchParams = z.infer<typeof applyPatchSchema>;
+export type ApplyPatchParams = typeof applyPatchSchema.infer;
 
 export type ApplyPatchEntry = PatchEditEntry & { path: string };
 

package/src/edit/modes/patch.ts

@@ -9,7 +9,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
 import { isEnoent } from "@oh-my-pi/pi-utils";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import {
 	type FileDiagnosticsResult,
 	flushLspWritethroughBatch,
@@ -1631,23 +1631,20 @@ export async function computePatchDiff(
 	}
 }
 
-export const patchEditEntrySchema = z
-	.object({
-		op: z.enum(["create", "delete", "update"]).optional().describe("operation (default update)"),
-		rename: z.string().describe("new path for move").optional(),
-		diff: z.string().describe("diff hunks or full content for create").optional(),
-	})
-	.strict();
-
-export const patchEditSchema = z
-	.object({
-		path: z.string().describe("file path"),
-		edits: z.array(patchEditEntrySchema).min(1).describe("patch operations"),
-	})
-	.strict();
-
-export type PatchEditEntry = z.infer<typeof patchEditEntrySchema>;
-export type PatchParams = z.infer<typeof patchEditSchema>;
+export const patchEditEntrySchema = type({
+	"op?": "'create' | 'delete' | 'update'",
+	"rename?": "string",
+	"diff?": "string",
+});
+
+export type PatchEditEntry = typeof patchEditEntrySchema.infer;
+
+export const patchEditSchema = type({
+	path: "string",
+	edits: patchEditEntrySchema.array(),
+});
+
+export type PatchParams = typeof patchEditSchema.infer;
 
 export interface ExecutePatchSingleOptions {
 	session: ToolSession;

package/src/edit/modes/replace.ts

@@ -5,7 +5,7 @@
  * fallback strategies for finding text in files.
  */
 import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import type { WritethroughCallback, WritethroughDeferredHandle } from "../../lsp";
 import type { ToolSession } from "../../tools";
 import { invalidateFsScanAfterWrite } from "../../tools/fs-cache-invalidation";
@@ -1010,23 +1010,19 @@ export function findContextLine(
 	return { index: undefined, confidence: bestScore };
 }
 
-export const replaceEditEntrySchema = z
-	.object({
-		old_text: z.string().describe("text to find"),
-		new_text: z.string().describe("replacement text"),
-		all: z.boolean().describe("replace all occurrences").optional(),
-	})
-	.strict();
+export const replaceEditEntrySchema = type({
+	old_text: "string",
+	new_text: "string",
+	"all?": "boolean",
+});
 
-export const replaceEditSchema = z
-	.object({
-		path: z.string().describe("file path"),
-		edits: z.array(replaceEditEntrySchema).min(1).describe("replacements"),
-	})
-	.strict();
+export const replaceEditSchema = type({
+	path: "string",
+	edits: replaceEditEntrySchema.array(),
+});
 
-export type ReplaceEditEntry = z.infer<typeof replaceEditEntrySchema>;
-export type ReplaceParams = z.infer<typeof replaceEditSchema>;
+export type ReplaceEditEntry = typeof replaceEditEntrySchema.infer;
+export type ReplaceParams = typeof replaceEditSchema.infer;
 
 export interface ExecuteReplaceSingleOptions {
 	session: ToolSession;
@@ -1042,7 +1038,7 @@ export interface ExecuteReplaceSingleOptions {
 
 export async function executeReplaceSingle(
 	options: ExecuteReplaceSingleOptions,
-): Promise<AgentToolResult<EditToolDetails, typeof replaceEditEntrySchema>> {
+): Promise<AgentToolResult<EditToolDetails, ReplaceEditEntry>> {
 	const {
 		session,
 		path,

package/src/edit/renderer.ts

@@ -591,7 +591,6 @@ export const editToolRenderer = {
 		uiTheme: Theme,
 	): Component {
 		const renderContext = options.renderContext;
-
 		const editArgs = args as EditRenderArgs;
 		const hashlineInputSummary = getHashlineInputRenderSummary(editArgs, renderContext?.editMode);
 		const applyPatchSummary = getApplyPatchRenderSummary(editArgs, options.isPartial, renderContext?.editMode);

package/src/eval/agent-bridge.ts

@@ -5,7 +5,7 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import { prompt, Snowflake } from "@oh-my-pi/pi-utils";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import { resolveAgentModelPatterns } from "../config/model-resolver";
 import type { LocalProtocolOptions } from "../internal-urls";
 import { MCPManager } from "../mcp/manager";
@@ -31,12 +31,12 @@ export const EVAL_AGENT_MAX_DEPTH = 3;
 const DEFAULT_AGENT_TYPE = "task";
 const DEFAULT_AGENT_LABEL = "EvalAgent";
 
-const agentArgsSchema = z.object({
-	prompt: z.string().min(1, "prompt must be a non-empty string"),
-	agentType: z.string().min(1).optional(),
-	model: z.union([z.string().min(1), z.array(z.string().min(1)).min(1)]).optional(),
-	label: z.string().optional(),
-	schema: z.unknown().optional(),
+const agentArgsSchema = type({
+	prompt: "string>0",
+	"agentType?": "string>0",
+	"model?": "string>0|string>0[]",
+	"label?": "string",
+	"schema?": "unknown",
 });
 
 interface EvalAgentArgs {
@@ -64,13 +64,11 @@ export interface EvalAgentResult {
 }
 
 function parseAgentArgs(args: unknown): EvalAgentArgs {
-	const parsed = agentArgsSchema.safeParse(args);
-	if (!parsed.success) {
-		const issue = parsed.error.issues[0];
-		const where = issue?.path.length ? `${issue.path.join(".")}: ` : "";
-		throw new ToolError(`agent() received invalid arguments: ${where}${issue?.message ?? "bad input"}`);
+	const result = agentArgsSchema(args);
+	if (result instanceof type.errors) {
+		throw new ToolError(`agent() received invalid arguments: ${result.summary}`);
 	}
-	return parsed.data;
+	return result;
 }
 
 function assertDepthAllowed(session: ToolSession): void {

package/src/eval/completion-bridge.ts

@@ -14,7 +14,7 @@
 import { instrumentedCompleteSimple, resolveTelemetry } from "@oh-my-pi/pi-agent-core";
 import { type Api, Effort, type Model, type Tool } from "@oh-my-pi/pi-ai";
 import { getSupportedEfforts } from "@oh-my-pi/pi-catalog/model-thinking";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import { extractTextContent, extractToolCall, parseJsonPayload } from "../commit/utils";
 
 import {
@@ -42,11 +42,11 @@ const TIER_TO_PATTERN: Record<CompletionTier, string> = {
 	slow: "pi/slow",
 };
 
-const completionArgsSchema = z.object({
-	prompt: z.string().min(1, "prompt must be a non-empty string"),
-	model: z.enum(["smol", "default", "slow"]).default("default"),
-	system: z.string().optional(),
-	schema: z.record(z.string(), z.unknown()).optional(),
+const completionArgsSchema = type({
+	prompt: "string>0",
+	"model?": "'smol'|'default'|'slow'",
+	"system?": "string",
+	"schema?": "Record<string,unknown>",
 });
 
 export interface EvalCompletionBridgeOptions {
@@ -107,18 +107,18 @@ export async function runEvalCompletion(
 	args: unknown,
 	options: EvalCompletionBridgeOptions,
 ): Promise<EvalCompletionResult> {
-	const parsed = completionArgsSchema.safeParse(args);
-	if (!parsed.success) {
-		const issue = parsed.error.issues[0];
-		const where = issue?.path.length ? `${issue.path.join(".")}: ` : "";
-		throw new ToolError(`completion() received invalid arguments: ${where}${issue?.message ?? "bad input"}`);
+	const parsed = completionArgsSchema(args);
+	if (parsed instanceof type.errors) {
+		throw new ToolError(`completion() received invalid arguments: ${parsed.summary}`);
 	}
-	const { prompt, model: tier, system, schema } = parsed.data;
+	const { prompt, model: modelTier, system, schema } = parsed;
+	// Apply default value for model if not provided
+	const finalTier: CompletionTier = modelTier ?? "default";
 
-	const model = resolveTierModel(tier, options.session);
+	const model = resolveTierModel(finalTier, options.session);
 	if (!model) {
 		throw new ToolError(
-			`completion() could not resolve a model for the "${tier}" tier. Configure modelRoles.${tier === "default" ? "default" : tier} or ensure a provider is available.`,
+			`completion() could not resolve a model for the "${finalTier}" tier. Configure modelRoles.${finalTier === "default" ? "default" : finalTier} or ensure a provider is available.`,
 		);
 	}
 
@@ -162,7 +162,7 @@ export async function runEvalCompletion(
 			{
 				apiKey: registry.resolver(model, options.session.getSessionId?.() ?? undefined),
 				signal: options.signal,
-				reasoning: reasoningForTier(tier, model),
+				reasoning: reasoningForTier(finalTier, model),
 				toolChoice: schema ? { type: "tool", name: STRUCTURED_TOOL_NAME } : undefined,
 			},
 			{ telemetry, oneshotKind: "eval_completion" },
@@ -197,7 +197,15 @@ export async function runEvalCompletion(
 		if (!resultText) throw new ToolError("completion() returned no text output.");
 	}
 
-	options.emitStatus?.({ op: "completion", model: formatModelString(model), tier, chars: resultText.length });
+	options.emitStatus?.({
+		op: "completion",
+		model: formatModelString(model),
+		tier: finalTier,
+		chars: resultText.length,
+	});
 
-	return { text: resultText, details: { model: formatModelString(model), tier, structured: Boolean(schema) } };
+	return {
+		text: resultText,
+		details: { model: formatModelString(model), tier: finalTier, structured: Boolean(schema) },
+	};
 }

package/src/eval/js/context-manager.ts

@@ -44,6 +44,8 @@ interface PendingRun {
 
 interface JsSession {
 	sessionKey: string;
+	sessionId: string;
+	cwd: string;
 	worker: WorkerHandle;
 	state: "alive" | "dead";
 	pending: Map<string, PendingRun>;
@@ -151,7 +153,14 @@ export async function disposeAllVmContexts(): Promise<void> {
  */
 export async function smokeTestJsEvalWorker(): Promise<void> {
 	const worker = spawnJsWorker();
-	const session: JsSession = { sessionKey: "smoke", worker, state: "alive", pending: new Map() };
+	const session: JsSession = {
+		sessionKey: "smoke",
+		sessionId: "smoke",
+		cwd: process.cwd(),
+		worker,
+		state: "alive",
+		pending: new Map(),
+	};
 	try {
 		await initWorker(session, { cwd: process.cwd(), sessionId: "smoke" }, WORKER_INIT_TIMEOUT_MS);
 		if (worker.mode !== "worker") {
@@ -219,7 +228,11 @@ async function runOnce(
 
 async function acquireSession(sessionKey: string, snapshot: SessionSnapshot, timeoutMs?: number): Promise<JsSession> {
 	const existing = sessions.get(sessionKey);
-	if (existing && existing.state === "alive") return existing;
+	if (existing && existing.state === "alive") {
+		existing.sessionId = snapshot.sessionId;
+		existing.cwd = snapshot.cwd;
+		return existing;
+	}
 	const starting = startingSessions.get(sessionKey);
 	if (starting) return await starting;
 
@@ -231,6 +244,8 @@ async function acquireSession(sessionKey: string, snapshot: SessionSnapshot, tim
 		const worker = spawnJsWorker();
 		const session: JsSession = {
 			sessionKey,
+			sessionId: snapshot.sessionId,
+			cwd: snapshot.cwd,
 			worker,
 			state: "alive",
 			pending: new Map(),

package/src/eval/js/index.ts

@@ -9,7 +9,7 @@ import { executeJs } from "./executor";
 
 const JS_SESSION_PREFIX = "js:";
 
-function namespaceSessionId(sessionId: string): string {
+export function namespaceSessionId(sessionId: string): string {
 	return sessionId.startsWith(JS_SESSION_PREFIX) ? sessionId : `${JS_SESSION_PREFIX}${sessionId}`;
 }
 

package/src/eval/py/executor.ts

@@ -632,7 +632,7 @@ async function executePerCall(code: string, cwd: string, options: PythonExecutor
 	}
 	const kernel = await startKernel(cwd, options);
 	try {
-		return await executeWithKernel(kernel, code, { ...options, cwd: undefined });
+		return await executeWithKernel(kernel, code, { ...options, cwd });
 	} finally {
 		await kernel.shutdown().catch(() => undefined);
 	}
@@ -682,7 +682,7 @@ async function executeOnSession(code: string, cwd: string, options: PythonExecut
 			throw new PythonExecutionCancelledError(false);
 		}
 	}
-	const runOptions = { ...options, cwd: undefined };
+	const runOptions = { ...options, cwd };
 	try {
 		return await executeWithKernel(session.kernel, code, runOptions);
 	} catch (err) {

package/src/extensibility/custom-commands/loader.ts

@@ -1,13 +1,14 @@
 /**
  * Custom command loader - loads TypeScript command modules using native Bun import.
  *
- * Dependencies (the zod-backed typebox shim and pi-coding-agent) are injected via the
+ * Dependencies (the arktype validation and pi-coding-agent) are injected via the
  * CustomCommandAPI to avoid import resolution issues with custom commands loaded from user directories.
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { getAgentDir, getProjectDir, isEnoent, logger } from "@oh-my-pi/pi-utils";
-import { z as zod } from "zod/v4";
+import * as arktype from "arktype";
+import * as zodModule from "zod/v4";
 import { getConfigDirs } from "../../config";
 import { execCommand } from "../../exec/exec";
 // Runtime self-reference: dereference this namespace only inside loader functions to keep the index.ts cycle safe.
@@ -186,7 +187,8 @@ export async function loadCustomCommands(options: LoadCustomCommandsOptions = {}
 		exec: (command: string, args: string[], execOptions) =>
 			execCommand(command, args, execOptions?.cwd ?? cwd, execOptions),
 		typebox,
-		zod,
+		arktype,
+		zod: zodModule,
 		pi: PiCodingAgent,
 	};
 

package/src/extensibility/custom-commands/types.ts

@@ -5,7 +5,8 @@
  * Unlike markdown commands which expand to prompts, custom commands can execute
  * arbitrary logic with full access to the hook context.
  */
-import type { z } from "zod/v4";
+import type * as arktype from "arktype";
+import type * as zod from "zod/v4";
 import type { ExecOptions, ExecResult, HookCommandContext } from "../../extensibility/hooks/types";
 import type * as PiCodingAgent from "../../index";
 import type * as TypeBox from "../typebox";
@@ -24,8 +25,10 @@ export interface CustomCommandAPI {
 	exec(command: string, args: string[], options?: ExecOptions): Promise<ExecResult>;
 	/** Injected zod-backed typebox shim (legacy/compat). */
 	typebox: typeof TypeBox;
-	/** Injected zod module for Zod-authored custom commands. */
-	zod: typeof z;
+	/** Injected arktype module for validation in custom commands. */
+	arktype: typeof arktype;
+	/** Injected zod/v4 module for canonical command validation. */
+	zod: typeof zod;
 	/** Injected pi-coding-agent exports */
 	pi: typeof PiCodingAgent;
 }

package/src/extensibility/custom-tools/loader.ts

@@ -7,7 +7,8 @@
 import * as path from "node:path";
 import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
 import { logger } from "@oh-my-pi/pi-utils";
-import { z } from "zod/v4";
+import { type } from "arktype";
+import * as zodModule from "zod/v4";
 import { toolCapability } from "../../capability/tool";
 import { type CustomTool, loadCapability } from "../../discovery";
 import type { ExecOptions } from "../../exec/exec";
@@ -108,7 +109,8 @@ export class CustomToolLoader {
 			hasUI: false,
 			logger,
 			typebox,
-			zod: z,
+			arktype: type,
+			zod: zodModule,
 			pi,
 			pushPendingAction: action => {
 				if (!pushPendingAction) {

package/src/extensibility/custom-tools/types.ts

@@ -15,7 +15,8 @@ import type { CompactionResult } from "@oh-my-pi/pi-agent-core/compaction";
 import type { FetchImpl, Model, Static, TSchema } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import type { logger as PiLogger } from "@oh-my-pi/pi-utils";
-import type { z } from "zod/v4";
+import type { type as ArkType } from "arktype";
+import type * as zod from "zod/v4";
 import type { Rule } from "../../capability/rule";
 import type { ModelRegistry } from "../../config/model-registry";
 import type { Settings } from "../../config/settings";
@@ -61,10 +62,12 @@ export interface CustomToolAPI {
 	hasUI: boolean;
 	/** File logger for error/warning/debug messages */
 	logger: typeof PiLogger;
-	/** Injected zod-backed typebox shim (legacy/compat — Zod-authored tools are preferred). */
+	/** Injected typebox shim (legacy/compat — arktype-authored tools are preferred). */
 	typebox: typeof TypeBox;
-	/** Injected zod module for Zod-authored custom tools. */
-	zod: typeof z;
+	/** Injected arktype module for arktype-authored custom tools. */
+	arktype: typeof ArkType;
+	/** Injected zod/v4 module for canonical parameter schemas. */
+	zod: typeof zod;
 	/** Injected pi-coding-agent exports */
 	pi: typeof PiCodingAgent;
 	/** Push a preview action that can later be resolved with the hidden resolve tool */
@@ -195,7 +198,7 @@ export interface CustomTool<TParams extends TSchema = TSchema, TDetails = any> {
 	strict?: boolean;
 	/** Description for LLM */
 	description: string;
-	/** Parameter schema (Zod or TypeBox; TypeBox is auto-lifted to Zod at registration). */
+	/** Parameter schema (arktype, TypeBox, or legacy formats). */
 	parameters: TParams;
 	/** If true, tool is excluded unless explicitly listed in --tools or agent's tools field */
 	hidden?: boolean;

package/src/extensibility/extensions/loader.ts

@@ -8,7 +8,8 @@ import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, Model, TextContent, TSchema } from "@oh-my-pi/pi-ai";
 import type { KeyId } from "@oh-my-pi/pi-tui";
 import { hasFsCode, isEacces, isEnoent, logger } from "@oh-my-pi/pi-utils";
-import { z } from "zod/v4";
+import { Type } from "arktype";
+import * as zodModule from "zod/v4";
 import { type ExtensionModule, extensionModuleCapability } from "../../capability/extension-module";
 import { type Hook, hookCapability } from "../../capability/hook";
 import { loadCapability } from "../../discovery";
@@ -123,7 +124,8 @@ export class ExtensionRuntime implements IExtensionRuntime {
 class ConcreteExtensionAPI implements ExtensionAPI, IExtensionRuntime {
 	readonly logger = logger;
 	readonly typebox = TypeBox;
-	readonly zod = z;
+	readonly arktype = Type;
+	readonly zod = zodModule;
 	readonly flagValues = new Map<string, boolean | string>();
 	readonly pendingProviderRegistrations: Array<{
 		name: string;

package/src/extensibility/extensions/types.ts

@@ -32,7 +32,8 @@ import type {
 import type { OAuthCredentials, OAuthLoginCallbacks } from "@oh-my-pi/pi-ai/oauth/types";
 import type { AutocompleteItem, Component, EditorTheme, KeyId, TUI } from "@oh-my-pi/pi-tui";
 import type { logger as PiLogger } from "@oh-my-pi/pi-utils";
-import type { z } from "zod/v4";
+import type { Type as arktype } from "arktype";
+import type * as zod from "zod/v4";
 import type { KeybindingsManager } from "../../config/keybindings";
 import type { ModelRegistry } from "../../config/model-registry";
 import type { EditToolDetails } from "../../edit";
@@ -948,8 +949,10 @@ export interface ExtensionAPI {
 	/** Injected zod-backed typebox shim for legacy `Type.Object(...)` parameter authoring. */
 	typebox: typeof TypeBox;
 
-	/** Injected zod module for Zod-authored extension tools (canonical going forward). */
-	zod: typeof z;
+	/** Injected arktype module for arktype-authored extension tools (canonical going forward). */
+	arktype: typeof arktype;
+	/** Injected zod/v4 module for canonical extension tool parameter schemas. */
+	zod: typeof zod;
 
 	/** Injected pi-coding-agent exports for accessing SDK utilities */
 	pi: typeof PiCodingAgent;

package/src/extensibility/hooks/loader.ts

@@ -3,7 +3,8 @@
  */
 import * as path from "node:path";
 import { logger } from "@oh-my-pi/pi-utils";
-import { z as zod } from "zod/v4";
+import * as arktype from "arktype";
+import * as zodModule from "zod/v4";
 import { hookCapability } from "../../capability/hook";
 import type { Hook } from "../../discovery";
 import { loadCapability } from "../../discovery";
@@ -139,7 +140,9 @@ async function createHookAPI(
 		},
 		logger,
 		typebox,
-		zod,
+		// HookAPI.arktype is typed as the arktype `Type` constructor; expose it from the module namespace.
+		arktype: arktype.Type,
+		zod: zodModule,
 		pi: PiCodingAgent,
 	} as HookAPI;
 

package/src/extensibility/hooks/types.ts

@@ -1,7 +1,8 @@
 import type { ImageContent, Message, Model, TextContent } from "@oh-my-pi/pi-ai";
 import type { Component, TUI } from "@oh-my-pi/pi-tui";
 import type { logger as PiLogger } from "@oh-my-pi/pi-utils";
-import type { z } from "zod/v4";
+import type { Type } from "arktype";
+import type * as zod from "zod/v4";
 import type { ModelRegistry } from "../../config/model-registry";
 import type { EditToolDetails } from "../../edit";
 import type { ExecOptions, ExecResult } from "../../exec/exec";
@@ -582,10 +583,12 @@ export interface HookAPI {
 
 	/** File logger for error/warning/debug messages */
 	logger: typeof PiLogger;
-	/** Injected zod-backed typebox shim (legacy/compat — prefer `zod`). */
+	/** Injected zod-backed typebox shim (legacy/compat — prefer `arktype`). */
 	typebox: typeof TypeBox;
-	/** Injected zod module for Zod-authored hooks. */
-	zod: typeof z;
+	/** Injected arktype module for arktype-authored hooks. */
+	arktype: typeof Type;
+	/** Injected zod/v4 module for canonical hook validation. */
+	zod: typeof zod;
 	/** Injected pi-coding-agent exports */
 	pi: typeof PiCodingAgent;
 }