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

package/src/extensibility/extensions/loader.ts

@@ -8,8 +8,7 @@ import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, Model, TextContent } 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 type { TSchema } from "@sinclair/typebox";
-import * as TypeBox from "@sinclair/typebox";
+import * as Zod from "zod/v4";
 import { type ExtensionModule, extensionModuleCapability } from "../../capability/extension-module";
 import { loadCapability } from "../../discovery";
 import { getExtensionNameFromPath } from "../../discovery/helpers";
@@ -19,6 +18,7 @@ import type { CustomMessage } from "../../session/messages";
 import { EventBus } from "../../utils/event-bus";
 import { installLegacyPiSpecifierShim, loadLegacyPiModule } from "../plugins/legacy-pi-compat";
 import { getAllPluginExtensionPaths } from "../plugins/loader";
+import * as TypeBox from "../typebox";
 
 import { resolvePath } from "../utils";
 import type {
@@ -119,6 +119,7 @@ export class ExtensionRuntime implements IExtensionRuntime {
 class ConcreteExtensionAPI implements ExtensionAPI, IExtensionRuntime {
 	readonly logger = logger;
 	readonly typebox = TypeBox;
+	readonly zod = Zod;
 	readonly flagValues = new Map<string, boolean | string>();
 	readonly pendingProviderRegistrations: Array<{
 		name: string;
@@ -140,7 +141,10 @@ class ConcreteExtensionAPI implements ExtensionAPI, IExtensionRuntime {
 		this.extension.handlers.set(event, list);
 	}
 
-	registerTool<TParams extends TSchema = TSchema, TDetails = unknown>(tool: ToolDefinition<TParams, TDetails>): void {
+	registerTool<
+		TParams extends import("@oh-my-pi/pi-ai").TSchema = import("@oh-my-pi/pi-ai").TSchema,
+		TDetails = unknown,
+	>(tool: ToolDefinition<TParams, TDetails>): void {
 		this.extension.tools.set(tool.name, {
 			definition: tool,
 			extensionPath: this.extension.path,

package/src/extensibility/extensions/types.ts

@@ -8,6 +8,7 @@
  * - Interact with the user via UI primitives
  */
 import type { AgentMessage, AgentToolResult, AgentToolUpdateCallback, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { CompactionResult } from "@oh-my-pi/pi-agent-core/compaction";
 import type {
 	Api,
 	AssistantMessageEvent,
@@ -17,12 +18,13 @@ import type {
 	Model,
 	ProviderResponseMetadata,
 	SimpleStreamOptions,
+	Static,
 	TextContent,
+	TSchema,
 } from "@oh-my-pi/pi-ai";
 import type { OAuthCredentials, OAuthLoginCallbacks } from "@oh-my-pi/pi-ai/utils/oauth/types";
 import type * as piCodingAgent from "@oh-my-pi/pi-coding-agent";
 import type { AutocompleteItem, Component, EditorTheme, KeyId, TUI } from "@oh-my-pi/pi-tui";
-import type { Static, TSchema } from "@sinclair/typebox";
 import type { KeybindingsManager } from "../../config/keybindings";
 import type { ModelRegistry } from "../../config/model-registry";
 import type { EditToolDetails } from "../../edit";
@@ -31,7 +33,6 @@ import type { BashResult } from "../../exec/bash-executor";
 import type { ExecOptions, ExecResult } from "../../exec/exec";
 import type { CustomEditor } from "../../modes/components/custom-editor";
 import type { Theme } from "../../modes/theme/theme";
-import type { CompactionResult } from "../../session/compaction";
 import type { CustomMessage } from "../../session/messages";
 import type { ReadonlySessionManager, SessionManager } from "../../session/session-manager";
 import type {
@@ -355,7 +356,7 @@ export interface ToolDefinition<TParams extends TSchema = TSchema, TDetails = un
 	label: string;
 	/** Description for LLM */
 	description: string;
-	/** Parameter schema (TypeBox) */
+	/** Parameter schema (Zod, or TypeBox for legacy/extension compat). */
 	parameters: TParams;
 	/** If true, tool is excluded unless explicitly listed in --tools or agent's tools field */
 	hidden?: boolean;
@@ -833,8 +834,11 @@ export interface ExtensionAPI {
 	/** File logger for error/warning/debug messages */
 	logger: typeof import("@oh-my-pi/pi-utils").logger;
 
-	/** Injected @sinclair/typebox module for defining tool parameters */
-	typebox: typeof import("@sinclair/typebox");
+	/** Injected zod-backed typebox shim for legacy `Type.Object(...)` parameter authoring. */
+	typebox: typeof import("../typebox");
+
+	/** Injected zod module for Zod-authored extension tools (canonical going forward). */
+	zod: typeof import("zod/v4");
 
 	/** Injected pi-coding-agent exports for accessing SDK utilities */
 	pi: typeof piCodingAgent;

package/src/extensibility/extensions/wrapper.ts

@@ -2,8 +2,7 @@
  * Tool wrappers for extensions.
  */
 import type { AgentTool, AgentToolContext, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
-import type { Static, TSchema } from "@sinclair/typebox";
+import type { ImageContent, Static, TextContent, TSchema } from "@oh-my-pi/pi-ai";
 import type { Theme } from "../../modes/theme/theme";
 import { applyToolProxy } from "../tool-proxy";
 import type { ExtensionRunner } from "./runner";

package/src/extensibility/hooks/loader.ts

@@ -3,12 +3,13 @@
  */
 import * as path from "node:path";
 import { logger } from "@oh-my-pi/pi-utils";
-import * as typebox from "@sinclair/typebox";
+import * as zod from "zod/v4";
 import { hookCapability } from "../../capability/hook";
 import type { Hook } from "../../discovery";
 import { loadCapability } from "../../discovery";
 import type { HookMessage } from "../../session/messages";
 import type { SessionManager } from "../../session/session-manager";
+import * as typebox from "../typebox";
 import { resolvePath } from "../utils";
 import { execCommand } from "./runner";
 import type { ExecOptions, HookAPI, HookFactory, HookMessageRenderer, RegisteredCommand } from "./types";
@@ -136,6 +137,7 @@ async function createHookAPI(
 		},
 		logger,
 		typebox,
+		zod,
 		pi: await import("@oh-my-pi/pi-coding-agent"),
 	} as HookAPI;
 

package/src/extensibility/hooks/tool-wrapper.ts

@@ -2,7 +2,7 @@
  * Tool wrapper - wraps tools with hook callbacks for interception.
  */
 import type { AgentTool, AgentToolContext, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import type { Static, TSchema } from "@sinclair/typebox";
+import type { Static, TSchema } from "@oh-my-pi/pi-ai";
 import { applyToolProxy } from "../tool-proxy";
 import type { HookRunner } from "./runner";
 import type { ToolCallEventResult, ToolResultEventResult } from "./types";

package/src/extensibility/hooks/types.ts

@@ -571,8 +571,10 @@ export interface HookAPI {
 
 	/** File logger for error/warning/debug messages */
 	logger: typeof import("@oh-my-pi/pi-utils").logger;
-	/** Injected @sinclair/typebox module */
-	typebox: typeof import("@sinclair/typebox");
+	/** Injected zod-backed typebox shim (legacy/compat — prefer `zod`). */
+	typebox: typeof import("../typebox");
+	/** Injected zod module for Zod-authored hooks. */
+	zod: typeof import("zod/v4");
 	/** Injected pi-coding-agent exports */
 	pi: typeof import("../..");
 }

package/src/extensibility/plugins/legacy-pi-compat.ts

@@ -47,6 +47,17 @@ const LEGACY_PI_FILE_PREFIX = "omp-legacy-pi-file:";
 const LEGACY_PI_FILE_NAMESPACE = "omp-legacy-pi-file";
 const resolvedSpecifierFallbacks = new Map<string, string>();
 
+// Extensions that imported `@sinclair/typebox` directly used to resolve against a
+// real `@sinclair/typebox` install. The runtime dep was replaced with the Zod-backed
+// shim under `extensibility/typebox.ts`; plugins still importing the public name
+// are redirected to that shim so existing extensions keep working without code
+// changes. Submodules like `@sinclair/typebox/compiler` are intentionally not
+// remapped — those expose TypeBox-only APIs the shim does not provide and plugins
+// relying on them must vendor `@sinclair/typebox` directly.
+const TYPEBOX_SPECIFIER = "@sinclair/typebox";
+const TYPEBOX_SPECIFIER_FILTER = /^@sinclair\/typebox$/;
+const TYPEBOX_SHIM_PATH = path.resolve(import.meta.dir, "../typebox.ts");
+
 let isLegacyPiSpecifierShimInstalled = false;
 
 function remapLegacyPiSpecifier(specifier: string): string | null {
@@ -99,6 +110,12 @@ const ANY_IMPORT_SPECIFIER_REGEX = /((?:from\s+|import\s*\(\s*)["'])([^"']+)(["'
 
 /** Resolve bare imports against the extension directory before loading mirrored legacy Pi files. */
 function isUrlLikeSpecifier(specifier: string): boolean {
+	// Windows drive-letter paths (e.g. `C:\foo` or `C:/foo`) also match the URL
+	// scheme shape `[A-Za-z][A-Za-z\d+.-]*:`. Treat them as filesystem paths so
+	// `toRewrittenImportSpecifier` converts them to `file://` URLs instead of
+	// emitting raw paths whose `\n`, `\U`, ... get eaten by TS string-literal
+	// escapes inside the mirrored extension file.
+	if (/^[a-zA-Z]:[\\/]/.test(specifier)) return false;
 	return /^[a-zA-Z][a-zA-Z\d+.-]*:/.test(specifier);
 }
 
@@ -117,6 +134,9 @@ function rewriteBareImportsForLegacyExtension(source: string, importerPath: stri
 		if (shouldPreserveImportSpecifier(specifier)) {
 			return match;
 		}
+		if (specifier === TYPEBOX_SPECIFIER) {
+			return `${prefix}${toRewrittenImportSpecifier(TYPEBOX_SHIM_PATH)}${suffix}`;
+		}
 		try {
 			const resolved = Bun.resolveSync(specifier, importerDir);
 			return `${prefix}${toRewrittenImportSpecifier(resolved)}${suffix}`;
@@ -223,6 +243,10 @@ function resolveLegacyPiSpecifier(args: { path: string }): { path: string } | un
 	};
 }
 
+function resolveTypeBoxSpecifier(): { path: string } {
+	return { path: TYPEBOX_SHIM_PATH };
+}
+
 export function installLegacyPiSpecifierShim(): void {
 	if (isLegacyPiSpecifierShimInstalled) {
 		return;
@@ -238,6 +262,12 @@ export function installLegacyPiSpecifierShim(): void {
 				resolveLegacyPiSpecifier,
 			);
 
+			build.onResolve({ filter: TYPEBOX_SPECIFIER_FILTER, namespace: "file" }, resolveTypeBoxSpecifier);
+			build.onResolve(
+				{ filter: TYPEBOX_SPECIFIER_FILTER, namespace: LEGACY_PI_FILE_NAMESPACE },
+				resolveTypeBoxSpecifier,
+			);
+
 			build.onResolve({ filter: /^omp-legacy-pi-file:/, namespace: "file" }, args => ({
 				path: args.path.slice(LEGACY_PI_FILE_PREFIX.length),
 				namespace: LEGACY_PI_FILE_NAMESPACE,

package/src/extensibility/shared-events.ts

@@ -13,10 +13,10 @@
  * `types.ts` files and is documented there.
  */
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import type { CompactionPreparation, CompactionResult } from "@oh-my-pi/pi-agent-core/compaction";
 import type { ImageContent, TextContent, ToolResultMessage } from "@oh-my-pi/pi-ai";
 import type { Rule } from "../capability/rule";
 import type { Goal, GoalModeState } from "../goals/state";
-import type { CompactionPreparation, CompactionResult } from "../session/compaction";
 import type { BranchSummaryEntry, CompactionEntry, SessionEntry } from "../session/session-manager";
 import type { TodoItem } from "../tools/todo-write";
 

package/src/extensibility/typebox.ts

@@ -0,0 +1,391 @@
+/**
+ * Minimal `@sinclair/typebox` runtime compatibility shim, backed by Zod.
+ *
+ * Historically the coding agent injected the real `@sinclair/typebox` (~5MB
+ * dependency) into extensions, hooks, custom tools, and custom commands so
+ * they could author parameter schemas as `Type.Object({ name: Type.String() })`.
+ * Internally everything already runs through Zod (`wire.ts`, `validation.ts`);
+ * the only reason TypeBox remained was extension-author compat.
+ *
+ * This module replaces that injection with a tiny façade whose `Type` builders
+ * return Zod schemas. Output is indistinguishable from hand-written Zod inside
+ * the agent pipeline:
+ *
+ *   - `isZodSchema()` keys off the Zod `_zod` marker that every schema carries.
+ *   - `zodToWireSchema()` emits the same draft-7 JSON Schema providers expect
+ *     from TypeBox-authored tools (defaulted fields treated as optional, etc.).
+ *
+ * The surface intentionally covers only the common TypeBox builders. Plugins
+ * that reached for niche TypeBox-only APIs (`TypeCompiler`, the global
+ * `TypeRegistry`, custom `Symbol(TypeBox.Kind)` introspection) must vendor
+ * `@sinclair/typebox` directly in their own package.
+ */
+
+import { areJsonValuesEqual } from "@oh-my-pi/pi-ai/utils/schema";
+import {
+	type ZodArray,
+	type ZodEnum,
+	type ZodObject,
+	type ZodOptional,
+	type ZodRawShape,
+	type ZodType,
+	z,
+} from "zod/v4";
+
+// ---------------------------------------------------------------------------
+// Type aliases — exported so `import type { Static, TSchema } from "..."`
+// patterns keep compiling at the call site.
+// ---------------------------------------------------------------------------
+
+export type TSchema = ZodType;
+export type Static<T extends ZodType> = z.infer<T>;
+export type TAny = ZodType;
+export type TUnknown = ZodType;
+export type TNever = ZodType;
+export type TNull = ZodType;
+export type TString = z.ZodString;
+export type TNumber = z.ZodNumber;
+export type TInteger = z.ZodNumber;
+export type TBoolean = z.ZodBoolean;
+export type TLiteral<V extends string | number | boolean> = z.ZodLiteral<V>;
+export type TArray<E extends ZodType> = ZodArray<E>;
+export type TObject<P extends ZodRawShape = ZodRawShape> = ZodObject<P>;
+export type TOptional<E extends ZodType> = ZodOptional<E>;
+export type TUnion<_T extends readonly ZodType[] = readonly ZodType[]> = ZodType;
+export type TEnum<T extends readonly (string | number)[] = readonly (string | number)[]> = ZodEnum<{
+	[K in T[number] as `${K}`]: K;
+}>;
+export type TRecord<_K extends ZodType, _V extends ZodType> = ZodType;
+
+// ---------------------------------------------------------------------------
+// Option shapes — loose subset of JSON Schema metadata + per-type constraints.
+// ---------------------------------------------------------------------------
+
+interface Meta {
+	title?: string;
+	description?: string;
+	default?: unknown;
+	examples?: unknown[];
+	// Real TypeBox accepts arbitrary extra JSON Schema keywords; we tolerate
+	// them silently so callers don't blow up on niche metadata.
+	[key: string]: unknown;
+}
+
+interface StringOpts extends Meta {
+	minLength?: number;
+	maxLength?: number;
+	pattern?: string;
+	format?: string;
+}
+
+interface NumberOpts extends Meta {
+	minimum?: number;
+	maximum?: number;
+	exclusiveMinimum?: number;
+	exclusiveMaximum?: number;
+	multipleOf?: number;
+}
+
+interface ArrayOpts extends Meta {
+	minItems?: number;
+	maxItems?: number;
+	uniqueItems?: boolean;
+}
+
+interface ObjectOpts extends Meta {
+	/**
+	 * TypeBox default: extra keys are preserved. Set `false` to reject unknowns,
+	 * `true` to allow any, or a schema to validate them.
+	 */
+	additionalProperties?: boolean | ZodType;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function withMeta<T extends ZodType>(schema: T, opts: Meta | undefined): T {
+	if (!opts) return schema;
+	let out: ZodType = schema;
+	if (typeof opts.description === "string") out = out.describe(opts.description);
+	if ("default" in opts) out = out.default(opts.default as never) as unknown as ZodType;
+
+	const metadata: Record<string, unknown> = {};
+	for (const [key, value] of Object.entries(opts)) {
+		if (key === "description" || key === "default" || key === "additionalProperties") continue;
+		metadata[key] = value;
+	}
+	if (Object.keys(metadata).length > 0) out = out.meta(metadata);
+	return out as T;
+}
+
+// ---------------------------------------------------------------------------
+// Builders
+// ---------------------------------------------------------------------------
+
+function tString(opts?: StringOpts): ZodType {
+	let s: ZodType = z.string();
+	if (opts) {
+		// Format selection swaps the base schema for a more specific Zod string
+		// validator that emits the right `format` keyword in JSON Schema.
+		switch (opts.format) {
+			case "email":
+				s = z.email();
+				break;
+			case "url":
+			case "uri":
+				s = z.url();
+				break;
+			case "uuid":
+				s = z.uuid();
+				break;
+			case "date-time":
+				s = z.iso.datetime();
+				break;
+			case "date":
+				s = z.iso.date();
+				break;
+			case "time":
+				s = z.iso.time();
+				break;
+			case "ipv4":
+				s = z.ipv4();
+				break;
+			case "ipv6":
+				s = z.ipv6();
+				break;
+			default:
+				break;
+		}
+		// Length/pattern constraints live on the `_ZodString` base that every
+		// format-specific schema (ZodEmail, ZodURL, ZodISODateTime, ...) extends,
+		// so we apply them regardless of which concrete subclass `s` ended up as.
+		const sf = s as z.ZodString;
+		if (typeof opts.minLength === "number") s = sf.min(opts.minLength);
+		if (typeof opts.maxLength === "number") s = (s as z.ZodString).max(opts.maxLength);
+		if (typeof opts.pattern === "string") s = (s as z.ZodString).regex(new RegExp(opts.pattern));
+	}
+	return withMeta(s, opts);
+}
+
+function applyNumberConstraints(base: z.ZodNumber, opts: NumberOpts | undefined): z.ZodNumber {
+	if (!opts) return base;
+	let out = base;
+	if (typeof opts.minimum === "number") out = out.min(opts.minimum);
+	if (typeof opts.maximum === "number") out = out.max(opts.maximum);
+	if (typeof opts.exclusiveMinimum === "number") out = out.gt(opts.exclusiveMinimum);
+	if (typeof opts.exclusiveMaximum === "number") out = out.lt(opts.exclusiveMaximum);
+	if (typeof opts.multipleOf === "number") out = out.multipleOf(opts.multipleOf);
+	return out;
+}
+
+function tNumber(opts?: NumberOpts): ZodType {
+	return withMeta(applyNumberConstraints(z.number(), opts), opts);
+}
+
+function tInteger(opts?: NumberOpts): ZodType {
+	return withMeta(applyNumberConstraints(z.number().int(), opts), opts);
+}
+
+function tBoolean(opts?: Meta): ZodType {
+	return withMeta(z.boolean(), opts);
+}
+
+function tNull(opts?: Meta): ZodType {
+	return withMeta(z.null(), opts);
+}
+
+function tAny(opts?: Meta): ZodType {
+	return withMeta(z.any(), opts);
+}
+
+function tUnknown(opts?: Meta): ZodType {
+	return withMeta(z.unknown(), opts);
+}
+
+function tNever(opts?: Meta): ZodType {
+	return withMeta(z.never(), opts);
+}
+
+function tLiteral<V extends string | number | boolean>(value: V, opts?: Meta): ZodType {
+	return withMeta(z.literal(value), opts);
+}
+
+function tUnion<T extends readonly ZodType[]>(schemas: T, opts?: Meta): ZodType {
+	if (schemas.length === 0) return withMeta(z.never(), opts);
+	if (schemas.length === 1) return withMeta(schemas[0] as ZodType, opts);
+	return withMeta(z.union(schemas as unknown as [ZodType, ZodType, ...ZodType[]]), opts);
+}
+
+function tIntersect(schemas: readonly ZodType[], opts?: Meta): ZodType {
+	if (schemas.length === 0) return withMeta(z.unknown(), opts);
+	if (schemas.length === 1) return withMeta(schemas[0] as ZodType, opts);
+	let out: ZodType = schemas[0] as ZodType;
+	for (let i = 1; i < schemas.length; i++) out = z.intersection(out, schemas[i] as ZodType) as ZodType;
+	return withMeta(out, opts);
+}
+
+function isArrayIndexKey(key: string): boolean {
+	if (!/^(?:0|[1-9]\\d*)$/.test(key)) return false;
+	const index = Number(key);
+	return Number.isSafeInteger(index) && index >= 0;
+}
+
+function uniqueLiteralValues(values: readonly (string | number | boolean)[]): Array<string | number | boolean> {
+	const unique: Array<string | number | boolean> = [];
+	for (const value of values) {
+		if (!unique.some(existing => existing === value)) unique.push(value);
+	}
+	return unique;
+}
+
+function literalUnion(values: readonly (string | number | boolean)[], opts?: Meta): ZodType {
+	const unique = uniqueLiteralValues(values);
+	if (unique.length === 0) return withMeta(z.never(), opts);
+	if (unique.length === 1) return withMeta(z.literal(unique[0] as string | number | boolean), opts);
+	const schemas = unique.map(value => z.literal(value as string | number | boolean)) as unknown as [
+		ZodType,
+		ZodType,
+		...ZodType[],
+	];
+	return withMeta(z.union(schemas), opts);
+}
+function tEnum<T extends Record<string, string | number> | readonly (string | number)[]>(
+	values: T,
+	opts?: Meta,
+): ZodType {
+	const list = Array.isArray(values)
+		? values
+		: Object.entries(values)
+				.filter(([key, value]) => !(isArrayIndexKey(key) && typeof value === "string"))
+				.map(([, value]) => value);
+	return literalUnion(list, opts);
+}
+
+function tArray<E extends ZodType>(item: E, opts?: ArrayOpts): ZodType {
+	let arr: ZodType = z.array(item);
+	if (opts) {
+		if (typeof opts.minItems === "number") arr = (arr as ZodArray<E>).min(opts.minItems);
+		if (typeof opts.maxItems === "number") arr = (arr as ZodArray<E>).max(opts.maxItems);
+		if (opts.uniqueItems === true) {
+			arr = arr.refine(items => {
+				if (!Array.isArray(items)) return true;
+				for (let i = 0; i < items.length; i += 1) {
+					for (let j = i + 1; j < items.length; j += 1) {
+						if (areJsonValuesEqual(items[i], items[j])) return false;
+					}
+				}
+				return true;
+			}, "Expected array items to be unique");
+		}
+	}
+	return withMeta(arr, opts);
+}
+
+function tTuple(items: readonly ZodType[], opts?: Meta): ZodType {
+	return withMeta(z.tuple(items as unknown as [ZodType, ...ZodType[]]) as unknown as ZodType, opts);
+}
+
+function isOptional(schema: ZodType): boolean {
+	const def = (schema as { _zod?: { def?: { type?: string } } })._zod?.def;
+	return def?.type === "optional";
+}
+
+function tObject<P extends ZodRawShape>(properties: P, opts?: ObjectOpts): ZodObject<P> {
+	// `z.object` automatically derives `required` from non-optional entries,
+	// so `Type.Optional(...)` flows through unchanged (Zod treats `.optional()`
+	// and `Type.Optional`-style wrappers identically).
+	let obj = z.object(properties);
+	const ap = opts?.additionalProperties;
+	if (ap === false) {
+		obj = obj.strict() as unknown as ZodObject<P>;
+	} else if (ap === undefined || ap === true) {
+		// TypeBox preserves unknown keys by default; Zod's default is `.strip()`.
+		obj = obj.loose() as unknown as ZodObject<P>;
+	} else {
+		obj = obj.catchall(ap) as unknown as ZodObject<P>;
+	}
+	return withMeta(obj, opts);
+}
+
+function tRecord<V extends ZodType>(key: ZodType, value: V, opts?: Meta): ZodType {
+	return withMeta(z.record(key as never, value as never) as unknown as ZodType, opts);
+}
+
+function tOptional<E extends ZodType>(schema: E, _opts?: Meta): ZodOptional<E> {
+	return isOptional(schema) ? (schema as unknown as ZodOptional<E>) : (schema.optional() as ZodOptional<E>);
+}
+
+function tNullable<E extends ZodType>(schema: E, opts?: Meta): ZodType {
+	return withMeta(schema.nullable() as ZodType, opts);
+}
+
+function tReadonly<E extends ZodType>(schema: E): E {
+	// TypeBox's `Type.Readonly` is purely a marker; runtime parsing is identical.
+	return schema;
+}
+
+function tPartial<P extends ZodRawShape>(obj: ZodObject<P>): ZodObject<P> {
+	return obj.partial() as unknown as ZodObject<P>;
+}
+
+function tRequired<P extends ZodRawShape>(obj: ZodObject<P>): ZodObject<P> {
+	return obj.required() as unknown as ZodObject<P>;
+}
+
+function tPick<P extends ZodRawShape, K extends keyof P>(obj: ZodObject<P>, keys: readonly K[]): ZodObject<Pick<P, K>> {
+	const mask = Object.fromEntries(keys.map(k => [k as string, true]));
+	return obj.pick(mask as never) as unknown as ZodObject<Pick<P, K>>;
+}
+
+function tOmit<P extends ZodRawShape, K extends keyof P>(obj: ZodObject<P>, keys: readonly K[]): ZodObject<Omit<P, K>> {
+	const mask = Object.fromEntries(keys.map(k => [k as string, true]));
+	return obj.omit(mask as never) as unknown as ZodObject<Omit<P, K>>;
+}
+
+function tComposite(objects: readonly ZodObject<ZodRawShape>[], opts?: Meta): ZodObject<ZodRawShape> {
+	// `Type.Composite([...])` flattens every object schema into one object schema
+	// rather than producing an intersection. Mirror that via repeated `extend`.
+	if (objects.length === 0) return withMeta(z.object({}), opts) as ZodObject<ZodRawShape>;
+	let out = objects[0] as ZodObject<ZodRawShape>;
+	for (let i = 1; i < objects.length; i += 1) {
+		out = out.extend(objects[i].shape) as ZodObject<ZodRawShape>;
+	}
+	return withMeta(out, opts) as ZodObject<ZodRawShape>;
+}
+
+// ---------------------------------------------------------------------------
+// Public `Type` namespace
+// ---------------------------------------------------------------------------
+
+export const Type = {
+	String: tString,
+	Number: tNumber,
+	Integer: tInteger,
+	Boolean: tBoolean,
+	Null: tNull,
+	Any: tAny,
+	Unknown: tUnknown,
+	Never: tNever,
+	Literal: tLiteral,
+	Union: tUnion,
+	Intersect: tIntersect,
+	Enum: tEnum,
+	Array: tArray,
+	Tuple: tTuple,
+	Object: tObject,
+	Record: tRecord,
+	Optional: tOptional,
+	Nullable: tNullable,
+	Readonly: tReadonly,
+	Partial: tPartial,
+	Required: tRequired,
+	Pick: tPick,
+	Omit: tOmit,
+	Composite: tComposite,
+} as const;
+
+export type TypeBuilder = typeof Type;
+
+/** Default namespace export so `import * as typebox from "./typebox"` still resolves the `Type` key. */
+export default { Type };

package/src/goals/tools/goal-tool.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 { formatNumber, 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, ThemeColor } from "../../modes/theme/theme";
 import goalDescription from "../../prompts/tools/goal.md" with { type: "text" };
@@ -14,19 +14,13 @@ import { renderStatusLine, truncateToWidth } from "../../tui";
 import { completionBudgetReport, remainingTokens } from "../runtime";
 import type { Goal, GoalStatus, GoalToolDetails } from "../state";
 
-const goalSchema = Type.Object({
-	op: Type.Union([Type.Literal("create"), Type.Literal("get"), Type.Literal("complete")], {
-		description: "Goal operation.",
-	}),
-	objective: Type.Optional(Type.String({ description: "Goal objective. Required when op=create." })),
-	token_budget: Type.Optional(
-		Type.Integer({
-			description: "Optional positive token budget. Only honored when op=create.",
-		}),
-	),
+const goalSchema = z.object({
+	op: z.union([z.literal("create"), z.literal("get"), z.literal("complete")]).describe("Goal operation."),
+	objective: z.string().describe("Goal objective. Required when op=create.").optional(),
+	token_budget: z.number().int().describe("Optional positive token budget. Only honored when op=create.").optional(),
 });
 
-export type GoalToolInput = Static<typeof goalSchema>;
+export type GoalToolInput = z.infer<typeof goalSchema>;
 
 export interface GoalToolResponse {
 	goal: Goal | null;

package/src/hashline/types.ts

@@ -1,5 +1,4 @@
-import type { Static } from "@sinclair/typebox";
-import { Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import type { LspBatchRequest } from "../edit/renderer";
 import type { WritethroughCallback, WritethroughDeferredHandle } from "../lsp";
 import type { ToolSession } from "../tools";
@@ -26,8 +25,9 @@ export type HashlineEdit =
 	| { kind: "insert"; cursor: HashlineCursor; text: string; lineNum: number; index: number }
 	| { kind: "delete"; anchor: Anchor; lineNum: number; index: number; oldAssertion?: string };
 
-export const hashlineEditParamsSchema = Type.Object({ input: Type.String() });
-export type HashlineParams = Static<typeof hashlineEditParamsSchema>;
+/** `path` is accepted by the edit tool runtime; other extra keys are preserved. */
+export const hashlineEditParamsSchema = z.object({ input: z.string(), path: z.string().optional() }).passthrough();
+export type HashlineParams = z.infer<typeof hashlineEditParamsSchema>;
 
 export interface HashlineStreamOptions {
 	/** First line number to use when formatting (1-indexed). */