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

package/src/config/settings-schema.ts

@@ -106,7 +106,7 @@ export const TAB_METADATA: Record<SettingTab, { label: string; icon: `tab.${stri
  */
 export const TAB_GROUPS: Record<SettingTab, readonly string[]> = {
 	appearance: ["Theme", "Status Line", "Display", "Images"],
-	model: ["Thinking", "Sampling", "Prompt", "Retry & Fallback", "Advisor"],
+	model: ["Thinking", "Sampling", "Prompt", "Retry & Fallback", "Advisor", "Vision"],
 	interaction: [
 		"Input",
 		"Approvals",
@@ -117,6 +117,7 @@ export const TAB_GROUPS: Record<SettingTab, readonly string[]> = {
 		"Startup & Updates",
 		"Power (macOS)",
 		"Agent",
+		"Git",
 	],
 	context: ["General", "Compaction", "Rules (TTSR)", "Experimental"],
 	memory: ["General", "Auto-Learn", "Mnemopi", "Hindsight"],
@@ -414,7 +415,36 @@ export const SETTINGS_SCHEMA = {
 				"Pause the main agent for up to 30 seconds if the advisor falls behind by this many turns. Off disables catch-up delays.",
 		},
 	},
+	"advisor.immuneTurns": {
+		type: "number",
+		default: 1,
+		ui: {
+			tab: "model",
+			group: "Advisor",
+			label: "Advisor Immune Turns",
+			description:
+				"After an advisor concern or blocker interrupts, route further concerns/blockers non-interruptingly for this many primary turns.",
+			options: [
+				{ value: "0", label: "0 turns", description: "Allow every concern/blocker to interrupt." },
+				{ value: "1", label: "1 turn", description: "Default." },
+				{ value: "2", label: "2 turns" },
+				{ value: "3", label: "3 turns" },
+				{ value: "4", label: "4 turns" },
+				{ value: "5", label: "5 turns" },
+			],
+		},
+	},
 	shellPath: { type: "string", default: undefined },
+	"git.enabled": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "interaction",
+			group: "Git",
+			label: "Enable Git Integration",
+			description: "Show git branch, status, and PR information in the TUI and watch repository metadata.",
+		},
+	},
 
 	extensions: { type: "array", default: EMPTY_STRING_ARRAY },
 
@@ -712,6 +742,18 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"images.describeForTextModels": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "model",
+			group: "Vision",
+			label: "Describe Images for Text Models",
+			description:
+				"When an image is attached to a model without vision support, save it under local:// and inject a description from a vision-capable model instead of dropping it",
+		},
+	},
+
 	"tui.maxInlineImageColumns": {
 		type: "number",
 		default: 100,
@@ -757,6 +799,16 @@ export const SETTINGS_SCHEMA = {
 				"Wrap paths and URLs in OSC 8 hyperlinks for terminal-native click-to-open (auto: detect support; off: never; always: unconditional)",
 		},
 	},
+	"tui.tight": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "appearance",
+			group: "Display",
+			label: "Tight Layout",
+			description: "Remove the 1-character horizontal padding from the left and right of the terminal output",
+		},
+	},
 	// Display rendering
 	"display.tabWidth": {
 		type: "number",
@@ -845,6 +897,28 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"model.loopGuard.enabled": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "model",
+			group: "Thinking",
+			label: "Loop Guard",
+			description: "Enable automatic stream loop detection for Gemini and DeepSeek models",
+		},
+	},
+
+	"model.loopGuard.checkAssistantContent": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "model",
+			group: "Thinking",
+			label: "Loop Guard Scan Prose",
+			description: "Apply loop guard to assistant prose messages in addition to thinking logs",
+		},
+	},
+
 	repeatToolDescriptions: {
 		type: "boolean",
 		default: false,
@@ -1284,6 +1358,18 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"startup.showSplash": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "interaction",
+			group: "Startup & Updates",
+			label: "Show Startup Splash",
+			description:
+				"Show the full animated setup splash on normal interactive startup without rerunning setup. Quiet Startup still suppresses it.",
+		},
+	},
+
 	"startup.setupWizard": {
 		type: "boolean",
 		default: true,
@@ -1505,7 +1591,7 @@ export const SETTINGS_SCHEMA = {
 	// Context promotion
 	"contextPromotion.enabled": {
 		type: "boolean",
-		default: true,
+		default: false,
 		ui: {
 			tab: "context",
 			group: "General",
@@ -1769,6 +1855,7 @@ export const SETTINGS_SCHEMA = {
 			"qwen3",
 			"gemini",
 			"gemma",
+			"minimax",
 		] as const,
 		default: "auto",
 		ui: {
@@ -1795,6 +1882,7 @@ export const SETTINGS_SCHEMA = {
 				{ value: "qwen3", label: "Qwen3", description: "Use the Qwen3 owned dialect." },
 				{ value: "gemini", label: "Gemini", description: "Use the Gemini owned dialect." },
 				{ value: "gemma", label: "Gemma", description: "Use the Gemma owned dialect." },
+				{ value: "minimax", label: "MiniMax", description: "Use the MiniMax owned dialect." },
 			],
 		},
 	},
@@ -3857,6 +3945,34 @@ export const SETTINGS_SCHEMA = {
 			description: "Providers that web_search should never use, even as fallbacks",
 		},
 	},
+	"providers.antigravityEndpoint": {
+		type: "enum",
+		values: ["auto", "production", "sandbox"] as const,
+		default: "auto",
+		ui: {
+			tab: "providers",
+			group: "Services",
+			label: "Antigravity Endpoint Mode",
+			description: "Endpoint routing strategy for google-antigravity providers (chat, search, image, discovery)",
+			options: [
+				{
+					value: "auto",
+					label: "Auto",
+					description: "Try production endpoint, fail over to sandbox on 5xx/429",
+				},
+				{
+					value: "production",
+					label: "Production Only",
+					description: "Force production endpoint only",
+				},
+				{
+					value: "sandbox",
+					label: "Sandbox Only",
+					description: "Force sandbox endpoint only",
+				},
+			],
+		},
+	},
 	"providers.image": {
 		type: "enum",
 		values: ["auto", "openai", "antigravity", "xai", "gemini", "openrouter"] as const,

package/src/discovery/builtin-rules/index.ts

@@ -19,6 +19,7 @@ import tsImportType from "./ts-import-type.md" with { type: "text" };
 import tsNoAny from "./ts-no-any.md" with { type: "text" };
 import tsNoDeprecatedLeftovers from "./ts-no-deprecated-leftovers.md" with { type: "text" };
 import tsNoDynamicImport from "./ts-no-dynamic-import.md" with { type: "text" };
+import tsNoInlineCastAccess from "./ts-no-inline-cast-access.md" with { type: "text" };
 import tsNoReturnType from "./ts-no-return-type.md" with { type: "text" };
 import tsNoTestTimers from "./ts-no-test-timers.md" with { type: "text" };
 import tsNoTinyFunctions from "./ts-no-tiny-functions.md" with { type: "text" };
@@ -45,6 +46,7 @@ export const BUILTIN_RULE_SOURCES: readonly BuiltinRuleSource[] = [
 	{ name: "ts-no-any", content: tsNoAny },
 	{ name: "ts-no-deprecated-leftovers", content: tsNoDeprecatedLeftovers },
 	{ name: "ts-no-dynamic-import", content: tsNoDynamicImport },
+	{ name: "ts-no-inline-cast-access", content: tsNoInlineCastAccess },
 	{ name: "ts-no-return-type", content: tsNoReturnType },
 	{ name: "ts-no-test-timers", content: tsNoTestTimers },
 	{ name: "ts-no-tiny-functions", content: tsNoTinyFunctions },

package/src/discovery/builtin-rules/ts-import-type.md

@@ -17,7 +17,7 @@ Use top-level `import type` declarations for type-only dependencies. NEVER write
 
 ```typescript
 // Bad — inline imports hide dependencies in signatures.
-function run(client: import("some-sdk").Client, input: import("zod/v4").infer<Schema>): Promise<Output>;
+function run(client: import("some-sdk").Client, input: import("arktype").infer<Schema>): Promise<Output>;
 
 // Bad — annotations become path dumps.
 const options: import("some-sdk/config").ClientOptions = { ... };
@@ -28,7 +28,7 @@ const options: import("some-sdk/config").ClientOptions = { ... };
 ```typescript
 import type { Client } from "some-sdk";
 import type { ClientOptions } from "some-sdk/config";
-import type { infer as Infer } from "zod/v4";
+import type { infer as Infer } from "arktype";
 
 function run(client: Client, input: Infer<Schema>): Promise<Output>;
 const options: ClientOptions = { ... };

package/src/discovery/builtin-rules/ts-no-any.md

@@ -1,5 +1,5 @@
 ---
-description: "Never use `any` in TypeScript annotations or assertions — use `unknown`, generics, or the actual type"
+description: "Never use `any` in TypeScript annotations or assertions — use `unknown`, generics, a schema parse at trust boundaries, or the actual type"
 condition: ": any|as any"
 scope: "tool:edit(*.ts), tool:edit(*.tsx), tool:write(*.ts), tool:write(*.tsx)"
 ---
@@ -9,6 +9,7 @@ Never use `: any` or `as any`. They disable type checking exactly where the boun
 ## Use instead
 
 - `unknown` for unvalidated input.
+- A schema parse (Zod, Valibot, …; e.g. Zod v4 when it is already in the project) for untrusted or external input — validate once, then consume a typed value.
 - A domain type when the shape is known.
 - A generic when the caller supplies the shape.
 - A type guard when runtime checks establish shape.
@@ -25,7 +26,7 @@ function readId(value: any): any {
 // Good — validate unknown input.
 function readId(value: unknown): string | undefined {
 	if (value && typeof value === "object" && "id" in value) {
-		const candidate = (value as { id: unknown }).id;
+		const candidate = value.id; // `in` narrowing types this as unknown — no cast needed
 		return typeof candidate === "string" ? candidate : undefined;
 	}
 }
@@ -53,4 +54,12 @@ const config = { port: 3000 } as any as ServerConfig;
 const config = { port: 3000 } satisfies ServerConfig;
 ```
 
+## Choosing: guard vs schema vs unchecked cast
+
+| Situation | Reach for |
+| --- | --- |
+| Data from outside your control — network/RPC, parsed JSON, config files, env vars, CLI/IPC, persisted blobs — or a shape reused across the codebase | **Schema parse** (Zod/Valibot/…): runtime validation, typed output, and a clear error on bad shape |
+| In-process value the compiler merely lost track of — an `unknown` from a generic, a union to discriminate, a one-off read of a field or two | **Type guard** (`in` / `typeof`): no dependency, but it only checks what you write, so keep the checked surface small |
+| You genuinely know more than the compiler *and* a runtime check is impossible or meaningless — a well-known DOM node (`as HTMLElement`), structurally-identical types inference can't unify, a library type that is wrong or unexpressible, `as const` | **Unchecked cast** (`as` / `as unknown as T`): assign to a named const with a one-line reason; never for raw external input |
+
 If a library boundary truly requires an unchecked cast, use `as unknown as T` with a short reason. Never leave a bare `any`.

package/src/discovery/builtin-rules/ts-no-inline-cast-access.md

@@ -0,0 +1,55 @@
+---
+description: "Don't assert an inline object type and immediately read a property — `(x as { y: T }).y` trusts an unchecked shape; validate with a schema parse at trust boundaries, narrow with `in`/`typeof`, or use a validated named type"
+scope: "tool:edit(*.{ts,tsx,mts,cts}), tool:write(*.{ts,tsx,mts,cts})"
+interruptMode: tool-only
+astCondition:
+  - "($X as { $$$BODY }).$PROP"
+  - "($X as { $$$BODY })?.$PROP"
+  - "($X as { $$$BODY })[$IDX]"
+---
+
+**Don't assert an inline object type just to read a property.** `(value as { content: unknown }).content` fabricates a shape the compiler never verified, then trusts it for exactly one access. If `value` isn't that shape, the read is silently wrong and no type error ever fires.
+
+## Why it's wrong
+
+- The cast is an unchecked assertion — it suppresses the type error instead of proving the shape.
+- It localizes the lie to one expression, so the next reader can't tell whether the value was ever validated.
+- It almost always stands in for the real fix: runtime narrowing or a validated type at the boundary.
+
+## Avoid
+
+```ts
+const content = (value as { content: unknown }).content;
+const id = (resp as { data: { id: string } }).data.id;
+const name = (payload as { name?: string })?.name;
+const flag = (opts as { enabled: boolean })["enabled"];
+```
+
+## Use
+
+Prefer a schema parse at the boundary when a validator is available (Zod, Valibot, …) — validate once, then read from a fully typed value. If Zod is already in the project (e.g. Zod v4):
+
+```ts
+import { z } from "zod/v4";
+
+const Resp = z.object({ data: z.object({ id: z.string() }) });
+
+const resp = Resp.parse(raw); // throws on bad input; resp.data.id is typed string
+const id = resp.data.id;
+```
+
+For a one-off read of a single field, narrow with `in` / `typeof` so the access is actually checked — TypeScript infers `unknown` for the property after `"content" in value`:
+
+```ts
+if (value && typeof value === "object" && "content" in value) {
+	const content = value.content; // unknown — validate before use
+}
+```
+
+## Choosing: guard vs schema vs unchecked cast
+
+| Situation | Reach for |
+| --- | --- |
+| Data from outside your control — network/RPC, parsed JSON, config files, env vars, CLI/IPC, persisted blobs — or a shape reused across the codebase | **Schema parse** (Zod/Valibot/…): runtime validation, typed output, and a clear error on bad shape |
+| In-process value the compiler merely lost track of — an `unknown` from a generic, a union to discriminate, a one-off read of a field or two | **Type guard** (`in` / `typeof`): no dependency, but it only checks what you write, so keep the checked surface small |
+| You genuinely know more than the compiler *and* a runtime check is impossible or meaningless — a well-known DOM node (`as HTMLElement`), structurally-identical types inference can't unify, a library type that's wrong or unexpressible, `as const` | **Unchecked cast** (`as`): assign to a named const with a one-line reason; never for raw external input, never inlined into a member access |

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) },
+	};
 }