@oh-my-pi/pi-coding-agent 4.4.6 → 4.4.9

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## [Unreleased]
 
+## [4.4.9] - 2026-01-12
+
+## [4.4.8] - 2026-01-12
+### Changed
+
+- Changed review finding priority format from numeric (0-3) to string labels (P0-P3) for clearer severity indication
+- Replaced Type.Union with Type.Literal patterns with StringEnum helper across tool schemas for cleaner enum definitions
+
 ## [4.4.6] - 2026-01-11
 
 ## [4.4.5] - 2026-01-11

package/examples/extensions/api-demo.ts

@@ -16,6 +16,9 @@ export default function (pi: ExtensionAPI) {
 	pi.logger.debug("API demo extension loaded");
 
 	// 3. Register a tool that uses all three API features
+	// Import StringEnum from typebox helpers
+	const { StringEnum } = pi.pi;
+
 	pi.registerTool({
 		name: "api_demo",
 		label: "API Demo",
@@ -23,7 +26,7 @@ export default function (pi: ExtensionAPI) {
 		parameters: Type.Object({
 			message: Type.String({ description: "Test message" }),
 			logLevel: Type.Optional(
-				Type.Union([Type.Literal("error"), Type.Literal("warn"), Type.Literal("debug")], {
+				StringEnum(["error", "warn", "debug"], {
 					description: "Log level to use",
 					default: "debug",
 				}),

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "4.4.6",
+	"version": "4.4.9",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -39,10 +39,10 @@
 		"prepublishOnly": "bun run generate-template && bun run clean && bun run build"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-ai": "4.4.6",
-		"@oh-my-pi/pi-agent-core": "4.4.6",
-		"@oh-my-pi/pi-git-tool": "4.4.6",
-		"@oh-my-pi/pi-tui": "4.4.6",
+		"@oh-my-pi/pi-ai": "4.4.9",
+		"@oh-my-pi/pi-agent-core": "4.4.9",
+		"@oh-my-pi/pi-git-tool": "4.4.9",
+		"@oh-my-pi/pi-tui": "4.4.9",
 		"@openai/agents": "^0.3.7",
 		"@sinclair/typebox": "^0.34.46",
 		"ajv": "^8.17.1",

package/src/core/tools/ask.ts

@@ -36,14 +36,10 @@ const OptionItem = Type.Object({
 
 const askSchema = Type.Object({
 	question: Type.String({ description: "The question to ask the user" }),
-	options: Type.Array(OptionItem, {
-		description: "Available options for the user to choose from.",
-		minItems: 1,
-	}),
+	options: Type.Array(OptionItem, { description: "Available options for the user to choose from." }),
 	multi: Type.Optional(
 		Type.Boolean({
 			description: "Allow multiple options to be selected (default: false)",
-			default: false,
 		}),
 	),
 });

package/src/core/tools/calculator.ts

@@ -44,7 +44,7 @@ const calculatorSchema = Type.Object({
 			prefix: Type.String({ description: "Text to prepend to the result" }),
 			suffix: Type.String({ description: "Text to append to the result" }),
 		}),
-		{ description: "List of calculations to evaluate", minItems: 1 },
+		{ description: "List of calculations to evaluate" },
 	),
 });
 

package/src/core/tools/complete.ts

@@ -5,6 +5,7 @@
  */
 
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import { StringEnum } from "@oh-my-pi/pi-ai";
 import { Type } from "@sinclair/typebox";
 import Ajv, { type ErrorObject, type ValidateFunction } from "ajv";
 import type { ToolSession } from "./index";
@@ -81,9 +82,8 @@ export function createCompleteTool(session: ToolSession) {
 	const completeParams = Type.Object({
 		data: Type.Optional(dataSchema),
 		status: Type.Optional(
-			Type.Union([Type.Literal("success"), Type.Literal("aborted")], {
-				default: "success",
-				description: "Use 'aborted' if the task cannot be completed",
+			StringEnum(["success", "aborted"], {
+				description: "Use 'aborted' if the task cannot be completed, defaults to 'success'",
 			}),
 		),
 		error: Type.Optional(Type.String({ description: "Error message when status is 'aborted'" })),

package/src/core/tools/exa/search.ts

@@ -4,6 +4,7 @@
  * Basic neural/keyword search, deep research, code search, and URL crawling.
  */
 
+import { StringEnum } from "@oh-my-pi/pi-ai";
 import { Type } from "@sinclair/typebox";
 import type { CustomTool } from "../../custom-tools/types";
 import type { ExaRenderDetails } from "./types";
@@ -31,7 +32,7 @@ Parameters:
 	parameters: Type.Object({
 		query: Type.String({ description: "Search query" }),
 		type: Type.Optional(
-			Type.Union([Type.Literal("keyword"), Type.Literal("neural"), Type.Literal("auto")], {
+			StringEnum(["keyword", "neural", "auto"], {
 				description: "Search type - neural (semantic), keyword (exact), or auto",
 			}),
 		),
@@ -128,7 +129,7 @@ Similar parameters to exa_search, optimized for research depth.`,
 	parameters: Type.Object({
 		query: Type.String({ description: "Research query" }),
 		type: Type.Optional(
-			Type.Union([Type.Literal("keyword"), Type.Literal("neural"), Type.Literal("auto")], {
+			StringEnum(["keyword", "neural", "auto"], {
 				description: "Search type - neural (semantic), keyword (exact), or auto",
 			}),
 		),

package/src/core/tools/find.ts

@@ -1,5 +1,6 @@
 import path from "node:path";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import { StringEnum } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
@@ -25,7 +26,7 @@ const findSchema = Type.Object({
 		Type.Boolean({ description: "Sort results by modification time, most recent first (default: false)" }),
 	),
 	type: Type.Optional(
-		Type.Union([Type.Literal("file"), Type.Literal("dir"), Type.Literal("all")], {
+		StringEnum(["file", "dir", "all"], {
 			description:
 				"Filter by type: 'file' for files only, 'dir' for directories only, 'all' for both (default: 'all')",
 		}),

package/src/core/tools/gemini-image.ts

@@ -1,5 +1,6 @@
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { StringEnum } from "@oh-my-pi/pi-ai";
 import { type Static, Type } from "@sinclair/typebox";
 import { nanoid } from "nanoid";
 import geminiImageDescription from "../../prompts/tools/gemini-image.md" with { type: "text" };
@@ -21,12 +22,11 @@ interface ImageApiKey {
 	apiKey: string;
 }
 
-const responseModalitySchema = Type.Union([Type.Literal("Image"), Type.Literal("Text")]);
-const aspectRatioSchema = Type.Union(
-	[Type.Literal("1:1"), Type.Literal("3:4"), Type.Literal("4:3"), Type.Literal("9:16"), Type.Literal("16:9")],
-	{ description: "Aspect ratio (1:1, 3:4, 4:3, 9:16, 16:9)." },
-);
-const imageSizeSchema = Type.Union([Type.Literal("1024x1024"), Type.Literal("1536x1024"), Type.Literal("1024x1536")], {
+const responseModalitySchema = StringEnum(["Image", "Text"]);
+const aspectRatioSchema = StringEnum(["1:1", "3:4", "4:3", "9:16", "16:9"], {
+	description: "Aspect ratio (1:1, 3:4, 4:3, 9:16, 16:9).",
+});
+const imageSizeSchema = StringEnum(["1024x1024", "1536x1024", "1024x1536"], {
 	description: "Image size, mainly for gemini-3-pro-image-preview.",
 });
 

package/src/core/tools/git.ts

@@ -1,4 +1,5 @@
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import { StringEnum } from "@oh-my-pi/pi-ai";
 import { type GitParams, gitTool as gitToolCore, type ToolResponse } from "@oh-my-pi/pi-git-tool";
 import { type Static, Type } from "@sinclair/typebox";
 import gitDescription from "../../prompts/tools/git.md" with { type: "text" };
@@ -6,50 +7,38 @@ import { renderPromptTemplate } from "../prompt-templates";
 import type { ToolSession } from "./index";
 
 const gitSchema = Type.Object({
-	operation: Type.Union([
-		Type.Literal("status"),
-		Type.Literal("diff"),
-		Type.Literal("log"),
-		Type.Literal("show"),
-		Type.Literal("blame"),
-		Type.Literal("branch"),
-		Type.Literal("add"),
-		Type.Literal("restore"),
-		Type.Literal("commit"),
-		Type.Literal("checkout"),
-		Type.Literal("merge"),
-		Type.Literal("rebase"),
-		Type.Literal("stash"),
-		Type.Literal("cherry-pick"),
-		Type.Literal("fetch"),
-		Type.Literal("pull"),
-		Type.Literal("push"),
-		Type.Literal("tag"),
-		Type.Literal("pr"),
-		Type.Literal("issue"),
-		Type.Literal("ci"),
-		Type.Literal("release"),
+	operation: StringEnum([
+		"status",
+		"diff",
+		"log",
+		"show",
+		"blame",
+		"branch",
+		"add",
+		"restore",
+		"commit",
+		"checkout",
+		"merge",
+		"rebase",
+		"stash",
+		"cherry-pick",
+		"fetch",
+		"pull",
+		"push",
+		"tag",
+		"pr",
+		"issue",
+		"ci",
+		"release",
 	]),
 
 	// Status
-	only: Type.Optional(
-		Type.Union([
-			Type.Literal("branch"),
-			Type.Literal("modified"),
-			Type.Literal("staged"),
-			Type.Literal("untracked"),
-			Type.Literal("conflicts"),
-			Type.Literal("sync"),
-		]),
-	),
+	only: Type.Optional(StringEnum(["branch", "modified", "staged", "untracked", "conflicts", "sync"])),
 	ignored: Type.Optional(Type.Boolean()),
 
 	// Diff
 	target: Type.Optional(
 		Type.Union([
-			Type.Literal("unstaged"),
-			Type.Literal("staged"),
-			Type.Literal("head"),
 			Type.Object({
 				from: Type.String(),
 				to: Type.Optional(Type.String()),
@@ -71,7 +60,7 @@ const gitSchema = Type.Object({
 	since: Type.Optional(Type.String()),
 	until: Type.Optional(Type.String()),
 	grep: Type.Optional(Type.String()),
-	format: Type.Optional(Type.Union([Type.Literal("oneline"), Type.Literal("short"), Type.Literal("full")])),
+	format: Type.Optional(StringEnum(["oneline", "short", "full"])),
 	stat: Type.Optional(Type.Boolean()),
 	merges: Type.Optional(Type.Boolean()),
 	first_parent: Type.Optional(Type.Boolean()),
@@ -90,15 +79,7 @@ const gitSchema = Type.Object({
 	root: Type.Optional(Type.Boolean()),
 
 	// Branch
-	action: Type.Optional(
-		Type.Union([
-			Type.Literal("list"),
-			Type.Literal("create"),
-			Type.Literal("delete"),
-			Type.Literal("rename"),
-			Type.Literal("current"),
-		]),
-	),
+	action: Type.Optional(StringEnum(["list", "create", "delete", "rename", "current"])),
 	name: Type.Optional(Type.String()),
 	newName: Type.Optional(Type.String()),
 	startPoint: Type.Optional(Type.String()),
@@ -165,13 +146,9 @@ const gitSchema = Type.Object({
 	base: Type.Optional(Type.String()),
 	head: Type.Optional(Type.String()),
 	draft: Type.Optional(Type.Boolean()),
-	state: Type.Optional(
-		Type.Union([Type.Literal("open"), Type.Literal("closed"), Type.Literal("merged"), Type.Literal("all")]),
-	),
-	merge_method: Type.Optional(Type.Union([Type.Literal("merge"), Type.Literal("squash"), Type.Literal("rebase")])),
-	review_action: Type.Optional(
-		Type.Union([Type.Literal("approve"), Type.Literal("request-changes"), Type.Literal("comment")]),
-	),
+	state: Type.Optional(StringEnum(["open", "closed", "merged", "all"])),
+	merge_method: Type.Optional(StringEnum(["merge", "squash", "rebase"])),
+	review_action: Type.Optional(StringEnum(["approve", "request-changes", "comment"])),
 	review_body: Type.Optional(Type.String()),
 
 	// Issue

package/src/core/tools/grep.ts

@@ -1,5 +1,6 @@
 import nodePath from "node:path";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import { StringEnum } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
@@ -44,7 +45,7 @@ const grepSchema = Type.Object({
 	),
 	limit: Type.Optional(Type.Number({ description: "Maximum number of matches to return (default: 100)" })),
 	outputMode: Type.Optional(
-		Type.Union([Type.Literal("content"), Type.Literal("files_with_matches"), Type.Literal("count")], {
+		StringEnum(["content", "files_with_matches", "count"], {
 			description:
 				"Output mode: 'content' shows matching lines, 'files_with_matches' shows only file paths, 'count' shows match counts per file (default: 'content')",
 		}),

package/src/core/tools/lsp/types.ts

@@ -1,3 +1,4 @@
+import { StringEnum } from "@oh-my-pi/pi-ai";
 import { type Static, Type } from "@sinclair/typebox";
 import type { Subprocess } from "bun";
 
@@ -6,28 +7,28 @@ import type { Subprocess } from "bun";
 // =============================================================================
 
 export const lspSchema = Type.Object({
-	action: Type.Union(
+	action: StringEnum(
 		[
 			// Standard LSP operations
-			Type.Literal("diagnostics"),
-			Type.Literal("workspace_diagnostics"),
-			Type.Literal("references"),
-			Type.Literal("definition"),
-			Type.Literal("hover"),
-			Type.Literal("symbols"),
-			Type.Literal("workspace_symbols"),
-			Type.Literal("rename"),
-			Type.Literal("actions"),
-			Type.Literal("incoming_calls"),
-			Type.Literal("outgoing_calls"),
-			Type.Literal("status"),
+			"diagnostics",
+			"workspace_diagnostics",
+			"references",
+			"definition",
+			"hover",
+			"symbols",
+			"workspace_symbols",
+			"rename",
+			"actions",
+			"incoming_calls",
+			"outgoing_calls",
+			"status",
 			// Rust-analyzer specific operations
-			Type.Literal("flycheck"),
-			Type.Literal("expand_macro"),
-			Type.Literal("ssr"),
-			Type.Literal("runnables"),
-			Type.Literal("related_tests"),
-			Type.Literal("reload_workspace"),
+			"flycheck",
+			"expand_macro",
+			"ssr",
+			"runnables",
+			"related_tests",
+			"reload_workspace",
 		],
 		{ description: "LSP action to perform" },
 	),

package/src/core/tools/notebook.ts

@@ -1,4 +1,5 @@
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import { StringEnum } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
@@ -17,14 +18,14 @@ import {
 } from "./render-utils";
 
 const notebookSchema = Type.Object({
-	action: Type.Union([Type.Literal("edit"), Type.Literal("insert"), Type.Literal("delete")], {
+	action: StringEnum(["edit", "insert", "delete"], {
 		description: "Action to perform on the notebook cell",
 	}),
 	notebook_path: Type.String({ description: "Path to the .ipynb file (relative or absolute)" }),
 	cell_index: Type.Number({ description: "0-based index of the cell to operate on" }),
 	content: Type.Optional(Type.String({ description: "New cell content (required for edit/insert)" })),
 	cell_type: Type.Optional(
-		Type.Union([Type.Literal("code"), Type.Literal("markdown")], {
+		StringEnum(["code", "markdown"], {
 			description: "Cell type for insert (default: code)",
 		}),
 	),

package/src/core/tools/output.ts

@@ -7,7 +7,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
-import type { TextContent } from "@oh-my-pi/pi-ai";
+import { StringEnum, type TextContent } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
@@ -30,10 +30,9 @@ import { getArtifactsDir } from "./task/artifacts";
 const outputSchema = Type.Object({
 	ids: Type.Array(Type.String(), {
 		description: "Agent output IDs to read (e.g., ['reviewer_0', 'explore_1'])",
-		minItems: 1,
 	}),
 	format: Type.Optional(
-		Type.Union([Type.Literal("raw"), Type.Literal("json"), Type.Literal("stripped")], {
+		StringEnum(["raw", "json", "stripped"], {
 			description: "Output format: raw (default), json (structured), stripped (no ANSI)",
 		}),
 	),

package/src/core/tools/review.ts

@@ -12,24 +12,33 @@ import { Container, Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
 import type { Theme, ThemeColor } from "../../modes/interactive/theme/theme";
 
-const PRIORITY_LABELS: Record<number, string> = {
-	0: "P0",
-	1: "P1",
-	2: "P2",
-	3: "P3",
+export type FindingPriority = "P0" | "P1" | "P2" | "P3";
+
+export interface FindingPriorityInfo {
+	ord: 0 | 1 | 2 | 3;
+	symbol: "status.error" | "status.warning" | "status.info";
+	color: ThemeColor;
+}
+
+const PRIORITY_INFO: Record<FindingPriority, FindingPriorityInfo> = {
+	P0: { ord: 0, symbol: "status.error", color: "error" },
+	P1: { ord: 1, symbol: "status.warning", color: "warning" },
+	P2: { ord: 2, symbol: "status.warning", color: "muted" },
+	P3: { ord: 3, symbol: "status.info", color: "accent" },
 };
 
-const PRIORITY_META: Record<number, { symbol: "status.error" | "status.warning" | "status.info"; color: ThemeColor }> =
-	{
-		0: { symbol: "status.error", color: "error" },
-		1: { symbol: "status.warning", color: "warning" },
-		2: { symbol: "status.warning", color: "muted" },
-		3: { symbol: "status.info", color: "accent" },
-	};
+export const PRIORITY_LABELS: FindingPriority[] = ["P0", "P1", "P2", "P3"];
+
+export function getPriorityInfo(priority: FindingPriority): FindingPriorityInfo {
+	return PRIORITY_INFO[priority] ?? { ord: 3, symbol: "status.info", color: "muted" };
+}
 
-function getPriorityDisplay(priority: number, theme: Theme): { label: string; icon: string; color: ThemeColor } {
-	const label = PRIORITY_LABELS[priority] ?? "P?";
-	const meta = PRIORITY_META[priority] ?? { symbol: "status.info", color: "muted" as const };
+function getPriorityDisplay(
+	priority: FindingPriority,
+	theme: Theme,
+): { label: string; icon: string; color: ThemeColor } {
+	const label = priority;
+	const meta = PRIORITY_INFO[priority] ?? { symbol: "status.info", color: "muted" as const };
 	return {
 		label,
 		icon: theme.styledSymbol(meta.symbol, meta.color),
@@ -45,7 +54,7 @@ const ReportFindingParams = Type.Object({
 	body: Type.String({
 		description: "Markdown explaining why this is a problem. One paragraph max.",
 	}),
-	priority: Type.Union([Type.Literal(0), Type.Literal(1), Type.Literal(2), Type.Literal(3)], {
+	priority: StringEnum(["P0", "P1", "P2", "P3"], {
 		description: "0=P0 (critical), 1=P1 (urgent), 2=P2 (normal), 3=P3 (low)",
 	}),
 	confidence: Type.Number({
@@ -61,7 +70,7 @@ const ReportFindingParams = Type.Object({
 interface ReportFindingDetails {
 	title: string;
 	body: string;
-	priority: number;
+	priority: FindingPriority;
 	confidence: number;
 	file_path: string;
 	line_start: number;
@@ -81,7 +90,7 @@ export const reportFindingTool: AgentTool<typeof ReportFindingParams, ReportFind
 			content: [
 				{
 					type: "text",
-					text: `Finding recorded: ${PRIORITY_LABELS[priority]} ${title}\nLocation: ${location}\nConfidence: ${(
+					text: `Finding recorded: ${priority} ${title}\nLocation: ${location}\nConfidence: ${(
 						confidence * 100
 					).toFixed(0)}%`,
 				},
@@ -91,7 +100,7 @@ export const reportFindingTool: AgentTool<typeof ReportFindingParams, ReportFind
 	},
 
 	renderCall(args, theme): Component {
-		const { label, icon, color } = getPriorityDisplay(args.priority as number, theme);
+		const { label, icon, color } = getPriorityDisplay(args.priority, theme);
 		const titleText = String(args.title).replace(/^\[P\d\]\s*/, "");
 		return new Text(
 			`${theme.fg("toolTitle", theme.bold("report_finding "))}${icon} ${theme.fg(color, `[${label}]`)} ${theme.fg(
@@ -141,6 +150,7 @@ export type { ReportFindingDetails };
 // ─────────────────────────────────────────────────────────────────────────────
 
 import path from "node:path";
+import { StringEnum } from "@oh-my-pi/pi-ai";
 import { subprocessToolRegistry } from "./task/subprocess-tool-registry";
 
 // Register report_finding handler

package/src/core/tools/schema-validation.test.ts

@@ -130,7 +130,7 @@ describe("sanitizeSchemaForGoogle", () => {
 		expect(sanitized).toEqual({ type: "string", enum: ["active", "inactive"] });
 	});
 
-	it("handles nested const in anyOf", () => {
+	it("collapses anyOf with const values into enum", () => {
 		const schema = {
 			anyOf: [
 				{ type: "string", const: "file" },
@@ -138,11 +138,10 @@ describe("sanitizeSchemaForGoogle", () => {
 			],
 		};
 		const sanitized = sanitizeSchemaForGoogle(schema);
+		// anyOf with all const values should collapse into a single enum
 		expect(sanitized).toEqual({
-			anyOf: [
-				{ type: "string", enum: ["file"] },
-				{ type: "string", enum: ["dir"] },
-			],
+			type: "string",
+			enum: ["file", "dir"],
 		});
 	});
 
@@ -179,7 +178,6 @@ describe("sanitizeSchemaForGoogle", () => {
 			type: "string",
 			enum: ["value"],
 			description: "A description",
-			minLength: 1,
 		});
 	});
 

package/src/core/tools/task/render.ts

@@ -18,18 +18,16 @@ import {
 	formatTokens,
 	truncate,
 } from "../render-utils";
-import type { ReportFindingDetails, SubmitReviewDetails } from "../review";
+import {
+	type FindingPriority,
+	getPriorityInfo,
+	PRIORITY_LABELS,
+	type ReportFindingDetails,
+	type SubmitReviewDetails,
+} from "../review";
 import { subprocessToolRegistry } from "./subprocess-tool-registry";
 import type { AgentProgress, SingleResult, TaskParams, TaskToolDetails } from "./types";
 
-/** Priority labels for review findings */
-const PRIORITY_LABELS: Record<number, string> = {
-	0: "P0",
-	1: "P1",
-	2: "P2",
-	3: "P3",
-};
-
 /**
  * Get status icon for agent state.
  * For running status, uses animated spinner if spinnerFrame is provided.
@@ -53,25 +51,17 @@ function getStatusIcon(status: AgentProgress["status"], theme: Theme, spinnerFra
 function formatFindingSummary(findings: ReportFindingDetails[], theme: Theme): string {
 	if (findings.length === 0) return theme.fg("dim", "Findings: none");
 
-	const counts = new Map<number, number>();
+	const counts: { [P in FindingPriority]?: number } = {};
 	for (const finding of findings) {
-		counts.set(finding.priority, (counts.get(finding.priority) ?? 0) + 1);
+		counts[finding.priority] = (counts[finding.priority] ?? 0) + 1;
 	}
 
-	const priorityMeta: Record<number, { icon: string; color: "error" | "warning" | "muted" | "accent" }> = {
-		0: { icon: theme.styledSymbol("status.error", "error"), color: "error" },
-		1: { icon: theme.styledSymbol("status.warning", "warning"), color: "warning" },
-		2: { icon: theme.styledSymbol("status.warning", "muted"), color: "muted" },
-		3: { icon: theme.styledSymbol("status.info", "accent"), color: "accent" },
-	};
-
 	const parts: string[] = [];
-	for (const priority of [0, 1, 2, 3]) {
-		const label = PRIORITY_LABELS[priority] ?? "P?";
-		const meta = priorityMeta[priority] ?? { icon: "", color: "muted" as const };
-		const count = counts.get(priority) ?? 0;
-		const text = theme.fg(meta.color, `${label}:${count}`);
-		parts.push(meta.icon ? `${meta.icon} ${text}` : text);
+	for (const label of PRIORITY_LABELS) {
+		const { symbol, color } = getPriorityInfo(label);
+		const count = counts[label] ?? 0;
+		const text = theme.fg(color, `${label}:${count}`);
+		parts.push(theme.styledSymbol(symbol, color) ? `${theme.styledSymbol(symbol, color)} ${text}` : text);
 	}
 
 	return `${theme.fg("dim", "Findings:")} ${parts.join(theme.sep.dot)}`;
@@ -467,7 +457,9 @@ function renderFindings(
 	const lines: string[] = [];
 
 	// Sort by priority (lower = more severe) when collapsed to show most important first
-	const sortedFindings = expanded ? findings : [...findings].sort((a, b) => a.priority - b.priority);
+	const sortedFindings = expanded
+		? findings
+		: [...findings].sort((a, b) => getPriorityInfo(a.priority).ord - getPriorityInfo(b.priority).ord);
 	const displayCount = expanded ? sortedFindings.length : Math.min(3, sortedFindings.length);
 
 	for (let i = 0; i < displayCount; i++) {
@@ -476,13 +468,12 @@ function renderFindings(
 		const findingPrefix = isLastFinding ? theme.tree.last : theme.tree.branch;
 		const findingContinue = isLastFinding ? "   " : `${theme.tree.vertical}  `;
 
-		const priority = PRIORITY_LABELS[finding.priority] ?? "P?";
-		const color = finding.priority === 0 ? "error" : finding.priority === 1 ? "warning" : "muted";
+		const { color } = getPriorityInfo(finding.priority);
 		const titleText = finding.title.replace(/^\[P\d\]\s*/, "");
 		const loc = `${path.basename(finding.file_path)}:${finding.line_start}`;
 
 		lines.push(
-			`${continuePrefix}${findingPrefix} ${theme.fg(color, `[${priority}]`)} ${titleText} ${theme.fg("dim", loc)}`,
+			`${continuePrefix}${findingPrefix} ${theme.fg(color, `[${finding.priority}]`)} ${titleText} ${theme.fg("dim", loc)}`,
 		);
 
 		// Show body when expanded

package/src/core/tools/task/types.ts

@@ -45,7 +45,6 @@ export const taskItemSchema = Type.Object({
 	id: Type.String({
 		description: "Short task identifier for display (max 32 chars, CamelCase, e.g. 'SessionStore', 'WebFetchFix')",
 		maxLength: 32,
-		pattern: "^[A-Za-z][A-Za-z0-9]*$",
 	}),
 	task: Type.String({ description: "Task description for the agent" }),
 	description: Type.String({ description: "Short description for UI display" }),
@@ -63,8 +62,8 @@ export const taskSchema = Type.Object({
 		}),
 	),
 	output: Type.Optional(
-		Type.Any({
-			description: "JTD schema for structured subagent output (used by the complete tool)",
+		Type.Record(Type.String(), Type.Unknown(), {
+			description: "JTD schema for structured subagent output",
 		}),
 	),
 	tasks: Type.Array(taskItemSchema, {

package/src/core/tools/todo-write.ts

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { mkdirSync } from "node:fs";
 import path from "node:path";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import { StringEnum } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
@@ -18,9 +19,9 @@ const todoWriteSchema = Type.Object({
 	todos: Type.Array(
 		Type.Object({
 			id: Type.Optional(Type.String({ description: "Stable todo id" })),
-			content: Type.String({ minLength: 1, description: "Imperative task description (e.g., 'Run tests')" }),
-			activeForm: Type.String({ minLength: 1, description: "Present continuous form (e.g., 'Running tests')" }),
-			status: Type.Union([Type.Literal("pending"), Type.Literal("in_progress"), Type.Literal("completed")]),
+			content: Type.String({ description: "Imperative task description (e.g., 'Run tests')" }),
+			activeForm: Type.String({ description: "Present continuous form (e.g., 'Running tests')" }),
+			status: StringEnum(["pending", "in_progress", "completed"]),
 		}),
 		{ description: "The updated todo list" },
 	),

package/src/core/tools/web-search/index.ts

@@ -13,6 +13,7 @@
  */
 
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import { StringEnum } from "@oh-my-pi/pi-ai";
 import { Type } from "@sinclair/typebox";
 import type { Theme } from "../../../modes/interactive/theme/theme";
 import webSearchDescription from "../../../prompts/tools/web-search.md" with { type: "text" };
@@ -36,7 +37,7 @@ export const webSearchSchema = Type.Object({
 	// Common
 	query: Type.String({ description: "Search query" }),
 	provider: Type.Optional(
-		Type.Union([Type.Literal("auto"), Type.Literal("exa"), Type.Literal("anthropic"), Type.Literal("perplexity")], {
+		StringEnum(["auto", "exa", "anthropic", "perplexity"], {
 			description: "Search provider (auto-detected if omitted or set to auto)",
 		}),
 	),
@@ -58,12 +59,12 @@ export const webSearchSchema = Type.Object({
 
 	// Perplexity-specific
 	model: Type.Optional(
-		Type.Union([Type.Literal("sonar"), Type.Literal("sonar-pro")], {
+		StringEnum(["sonar", "sonar-pro"], {
 			description: "Perplexity model - sonar (fast) or sonar-pro (comprehensive research)",
 		}),
 	),
 	search_recency_filter: Type.Optional(
-		Type.Union([Type.Literal("day"), Type.Literal("week"), Type.Literal("month"), Type.Literal("year")], {
+		StringEnum(["day", "week", "month", "year"], {
 			description: "Filter results by recency (Perplexity only)",
 		}),
 	),
@@ -73,7 +74,7 @@ export const webSearchSchema = Type.Object({
 		}),
 	),
 	search_context_size: Type.Optional(
-		Type.Union([Type.Literal("low"), Type.Literal("medium"), Type.Literal("high")], {
+		StringEnum(["low", "medium", "high"], {
 			description: "Context size for cost control (Perplexity only)",
 		}),
 	),
@@ -379,7 +380,7 @@ export function createWebSearchTool(_session: ToolSession): AgentTool<typeof web
 const webSearchDeepSchema = Type.Object({
 	query: Type.String({ description: "Research query" }),
 	type: Type.Optional(
-		Type.Union([Type.Literal("keyword"), Type.Literal("neural"), Type.Literal("auto")], {
+		StringEnum(["keyword", "neural", "auto"], {
 			description: "Search type - neural (semantic), keyword (exact), or auto",
 		}),
 	),

package/src/index.ts

@@ -1,5 +1,8 @@
 // Core session management
 
+// TypeBox helper for string enums (convenience for custom tools)
+// Re-export from pi-ai which uses the correct enum-based schema format
+export { StringEnum } from "@oh-my-pi/pi-ai";
 // Re-export TUI components for custom tool rendering
 export { Container, Markdown, Spacer, Text } from "@oh-my-pi/pi-tui";
 export {
@@ -264,15 +267,3 @@ export {
 	Theme,
 	type ThemeColor,
 } from "./modes/interactive/theme/theme";
-
-// TypeBox helper for string enums (convenience for custom tools)
-import { type TSchema, Type } from "@sinclair/typebox";
-export function StringEnum<T extends readonly string[]>(
-	values: T,
-	options?: { description?: string; default?: T[number] },
-): TSchema {
-	return Type.Union(
-		values.map((v) => Type.Literal(v)),
-		options,
-	);
-}

package/src/modes/interactive/theme/theme.ts

@@ -824,6 +824,7 @@ const ColorValueSchema = Type.Union([
 
 type ColorValue = Static<typeof ColorValueSchema>;
 
+// Use Type.Union here (not StringEnum) because TypeCompiler doesn't support Type.Unsafe
 const SymbolPresetSchema = Type.Union([Type.Literal("unicode"), Type.Literal("nerd"), Type.Literal("ascii")]);
 
 const SymbolsSchema = Type.Optional(