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

package/dist/types/tools/image-gen.d.ts

@@ -1,44 +1,28 @@
 import { type Model } from "@oh-my-pi/pi-ai";
-import { z } from "zod/v4";
 import { type ModelRegistry } from "../config/model-registry";
 import type { CustomTool } from "../extensibility/custom-tools/types";
 export type ImageProvider = "antigravity" | "gemini" | "openai" | "openai-codex" | "openrouter" | "xai";
 export type ImageProviderPreference = Exclude<ImageProvider, "openai-codex"> | "auto";
-declare const responseModalitySchema: z.ZodEnum<{
-    IMAGE: "IMAGE";
-    TEXT: "TEXT";
-}>;
-export declare const imageGenSchema: z.ZodObject<{
-    subject: z.ZodString;
-    action: z.ZodOptional<z.ZodString>;
-    scene: z.ZodOptional<z.ZodString>;
-    composition: z.ZodOptional<z.ZodString>;
-    lighting: z.ZodOptional<z.ZodString>;
-    style: z.ZodOptional<z.ZodString>;
-    text: z.ZodOptional<z.ZodString>;
-    changes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    aspect_ratio: z.ZodOptional<z.ZodEnum<{
-        "16:9": "16:9";
-        "1:1": "1:1";
-        "2:3": "2:3";
-        "3:2": "3:2";
-        "3:4": "3:4";
-        "4:3": "4:3";
-        "9:16": "9:16";
-    }>>;
-    image_size: z.ZodOptional<z.ZodEnum<{
-        "1024x1024": "1024x1024";
-        "1024x1536": "1024x1536";
-        "1536x1024": "1536x1024";
-    }>>;
-    input: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        path: z.ZodOptional<z.ZodString>;
-        data: z.ZodOptional<z.ZodString>;
-        mime_type: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>>;
-}, z.core.$strict>;
-export type ImageGenParams = z.infer<typeof imageGenSchema>;
-export type GeminiResponseModality = z.infer<typeof responseModalitySchema>;
+declare const responseModalitySchema: import("arktype/internal/variants/string.ts").StringType<"IMAGE" | "TEXT", {}>;
+export declare const imageGenSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    subject: string;
+    action?: string | undefined;
+    scene?: string | undefined;
+    composition?: string | undefined;
+    lighting?: string | undefined;
+    style?: string | undefined;
+    text?: string | undefined;
+    changes?: string[] | undefined;
+    aspect_ratio?: "16:9" | "1:1" | "2:3" | "3:2" | "3:4" | "4:3" | "9:16" | undefined;
+    image_size?: "1024x1024" | "1024x1536" | "1536x1024" | undefined;
+    input?: {
+        path?: string | undefined;
+        data?: string | undefined;
+        mime_type?: string | undefined;
+    }[] | undefined;
+}, {}>;
+export type ImageGenParams = typeof imageGenSchema.infer;
+export type GeminiResponseModality = typeof responseModalitySchema.infer;
 interface GeminiSafetyRating {
     category?: string;
     probability?: string;

package/dist/types/tools/inspect-image.d.ts

@@ -1,12 +1,11 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { completeSimple, type ToolExample } from "@oh-my-pi/pi-ai";
-import { z } from "zod/v4";
 import type { ToolSession } from "./index";
-declare const inspectImageSchema: z.ZodObject<{
-    path: z.ZodString;
-    question: z.ZodString;
-}, z.core.$strict>;
-export type InspectImageParams = z.infer<typeof inspectImageSchema>;
+declare const inspectImageSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    path: string;
+    question: string;
+}, {}>;
+export type InspectImageParams = typeof inspectImageSchema.infer;
 export interface InspectImageToolDetails {
     model: string;
     imagePath: string;
@@ -21,12 +20,12 @@ export declare class InspectImageTool implements AgentTool<typeof inspectImageSc
     readonly loadMode = "discoverable";
     readonly summary = "Describe or analyze an image file";
     readonly description: string;
-    readonly parameters: z.ZodObject<{
-        path: z.ZodString;
-        question: z.ZodString;
-    }, z.core.$strict>;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        path: string;
+        question: string;
+    }, {}>;
     readonly strict = false;
-    readonly examples: readonly ToolExample<z.input<typeof inspectImageSchema>>[];
+    readonly examples: readonly ToolExample<typeof inspectImageSchema.infer>[];
     constructor(session: ToolSession, completeImageRequest?: typeof completeSimple);
     execute(_toolCallId: string, params: InspectImageParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<InspectImageToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<InspectImageToolDetails>>;
 }

package/dist/types/tools/irc.d.ts

@@ -11,7 +11,6 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { ToolExample } from "@oh-my-pi/pi-ai";
 import { type Component } from "@oh-my-pi/pi-tui";
-import { z } from "zod/v4";
 import type { Settings } from "../config/settings";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type IrcDeliveryReceipt, type IrcMessage } from "../irc/bus";
@@ -24,22 +23,17 @@ import type { ToolSession } from ".";
  * top-level session with task spawning unavailable has no peers — no irc.
  */
 export declare function isIrcEnabled(settings: Settings, taskDepth: number): boolean;
-declare const ircSchema: z.ZodObject<{
-    op: z.ZodEnum<{
-        inbox: "inbox";
-        list: "list";
-        send: "send";
-        wait: "wait";
-    }>;
-    to: z.ZodOptional<z.ZodString>;
-    message: z.ZodOptional<z.ZodString>;
-    replyTo: z.ZodOptional<z.ZodString>;
-    await: z.ZodOptional<z.ZodBoolean>;
-    from: z.ZodOptional<z.ZodString>;
-    timeoutMs: z.ZodOptional<z.ZodNumber>;
-    peek: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-type IrcParams = z.infer<typeof ircSchema>;
+declare const ircSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    op: "inbox" | "list" | "send" | "wait";
+    to?: string | undefined;
+    message?: string | undefined;
+    replyTo?: string | undefined;
+    await?: boolean | undefined;
+    from?: string | undefined;
+    timeoutMs?: number | undefined;
+    peek?: boolean | undefined;
+}, {}>;
+type IrcParams = typeof ircSchema.infer;
 interface IrcPeerInfo {
     id: string;
     displayName: string;
@@ -68,23 +62,18 @@ export declare class IrcTool implements AgentTool<typeof ircSchema, IrcDetails>
     readonly label = "IRC";
     readonly summary = "Send and receive messages between agents";
     readonly description: string;
-    readonly parameters: z.ZodObject<{
-        op: z.ZodEnum<{
-            inbox: "inbox";
-            list: "list";
-            send: "send";
-            wait: "wait";
-        }>;
-        to: z.ZodOptional<z.ZodString>;
-        message: z.ZodOptional<z.ZodString>;
-        replyTo: z.ZodOptional<z.ZodString>;
-        await: z.ZodOptional<z.ZodBoolean>;
-        from: z.ZodOptional<z.ZodString>;
-        timeoutMs: z.ZodOptional<z.ZodNumber>;
-        peek: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        op: "inbox" | "list" | "send" | "wait";
+        to?: string | undefined;
+        message?: string | undefined;
+        replyTo?: string | undefined;
+        await?: boolean | undefined;
+        from?: string | undefined;
+        timeoutMs?: number | undefined;
+        peek?: boolean | undefined;
+    }, {}>;
     readonly strict = true;
-    readonly examples: readonly ToolExample<z.input<typeof ircSchema>>[];
+    readonly examples: readonly ToolExample<typeof ircSchema.infer>[];
     readonly loadMode = "discoverable";
     constructor(session: ToolSession);
     static createIf(session: ToolSession): IrcTool | null;

package/dist/types/tools/job.d.ts

@@ -1,15 +1,14 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
-import { z } from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import type { ToolSession } from "./index";
-declare const jobSchema: z.ZodObject<{
-    poll: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    cancel: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    list: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-type JobParams = z.infer<typeof jobSchema>;
+declare const jobSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    poll?: string[] | undefined;
+    cancel?: string[] | undefined;
+    list?: boolean | undefined;
+}, {}>;
+type JobParams = typeof jobSchema.infer;
 interface JobSnapshot {
     id: string;
     type: "bash" | "task";
@@ -42,11 +41,11 @@ export declare class JobTool implements AgentTool<typeof jobSchema, JobToolDetai
     readonly label = "Job";
     readonly summary = "Manage long-running background jobs (async bash/python)";
     readonly description: string;
-    readonly parameters: z.ZodObject<{
-        poll: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        cancel: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        list: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        poll?: string[] | undefined;
+        cancel?: string[] | undefined;
+        list?: boolean | undefined;
+    }, {}>;
     readonly strict = true;
     readonly interruptible = true;
     readonly loadMode = "discoverable";

package/dist/types/tools/learn.d.ts

@@ -1,20 +1,16 @@
 import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import { z } from "zod/v4";
 import type { ToolSession } from ".";
-declare const learnSchema: z.ZodObject<{
-    memory: z.ZodString;
-    context: z.ZodOptional<z.ZodString>;
-    skill: z.ZodOptional<z.ZodObject<{
-        action: z.ZodEnum<{
-            create: "create";
-            update: "update";
-        }>;
-        name: z.ZodString;
-        description: z.ZodString;
-        body: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type LearnParams = z.infer<typeof learnSchema>;
+declare const learnSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    memory: string;
+    context?: string | undefined;
+    skill?: {
+        action: "create" | "update";
+        name: string;
+        description: string;
+        body: string;
+    } | undefined;
+}, {}>;
+export type LearnParams = typeof learnSchema.infer;
 /**
  * Orchestrating "learn" tool: persists a lesson to long-term memory and,
  * given a `skill` payload, mints/enhances a managed skill via the shared
@@ -28,19 +24,16 @@ export declare class LearnTool implements AgentTool<typeof learnSchema> {
     readonly approval: (args: unknown) => "read" | "write";
     readonly label = "Learn";
     readonly description: string;
-    readonly parameters: z.ZodObject<{
-        memory: z.ZodString;
-        context: z.ZodOptional<z.ZodString>;
-        skill: z.ZodOptional<z.ZodObject<{
-            action: z.ZodEnum<{
-                create: "create";
-                update: "update";
-            }>;
-            name: z.ZodString;
-            description: z.ZodString;
-            body: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        memory: string;
+        context?: string | undefined;
+        skill?: {
+            action: "create" | "update";
+            name: string;
+            description: string;
+            body: string;
+        } | undefined;
+    }, {}>;
     readonly strict = true;
     readonly loadMode: "essential";
     readonly summary = "Capture a reusable lesson to memory (and optionally a managed skill)";

package/dist/types/tools/manage-skill.d.ts

@@ -1,17 +1,12 @@
 import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import { z } from "zod/v4";
 import type { ToolSession } from ".";
-declare const manageSkillSchema: z.ZodObject<{
-    action: z.ZodEnum<{
-        create: "create";
-        delete: "delete";
-        update: "update";
-    }>;
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    body: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type ManageSkillParams = z.infer<typeof manageSkillSchema>;
+declare const manageSkillSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    action: "create" | "delete" | "update";
+    name: string;
+    description?: string | undefined;
+    body?: string | undefined;
+}, {}>;
+export type ManageSkillParams = typeof manageSkillSchema.infer;
 /**
  * Direct create/update/delete of isolated managed skills. Gated behind
  * `autolearn.enabled`; backend-independent (the skill side is standalone).
@@ -21,16 +16,12 @@ export declare class ManageSkillTool implements AgentTool<typeof manageSkillSche
     readonly approval: "write";
     readonly label = "Manage Skill";
     readonly description: string;
-    readonly parameters: z.ZodObject<{
-        action: z.ZodEnum<{
-            create: "create";
-            delete: "delete";
-            update: "update";
-        }>;
-        name: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-        body: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        action: "create" | "delete" | "update";
+        name: string;
+        description?: string | undefined;
+        body?: string | undefined;
+    }, {}>;
     readonly strict = true;
     readonly loadMode: "essential";
     readonly summary = "Create, update, or delete an isolated managed skill";

package/dist/types/tools/memory-edit.d.ts

@@ -1,35 +1,26 @@
 import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import { z } from "zod/v4";
 import type { ToolSession } from ".";
-declare const memoryEditSchema: z.ZodObject<{
-    op: z.ZodEnum<{
-        forget: "forget";
-        invalidate: "invalidate";
-        update: "update";
-    }>;
-    id: z.ZodString;
-    content: z.ZodOptional<z.ZodString>;
-    importance: z.ZodOptional<z.ZodNumber>;
-    replacement_id: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type MemoryEditParams = z.infer<typeof memoryEditSchema>;
+declare const memoryEditSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    op: "forget" | "invalidate" | "update";
+    id: string;
+    content?: string | undefined;
+    importance?: number | undefined;
+    replacement_id?: string | undefined;
+}, {}>;
+export type MemoryEditParams = typeof memoryEditSchema.infer;
 export declare class MemoryEditTool implements AgentTool<typeof memoryEditSchema> {
     private readonly session;
     readonly name = "memory_edit";
     readonly approval: "read";
     readonly label = "Memory Edit";
     readonly description: string;
-    readonly parameters: z.ZodObject<{
-        op: z.ZodEnum<{
-            forget: "forget";
-            invalidate: "invalidate";
-            update: "update";
-        }>;
-        id: z.ZodString;
-        content: z.ZodOptional<z.ZodString>;
-        importance: z.ZodOptional<z.ZodNumber>;
-        replacement_id: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        op: "forget" | "invalidate" | "update";
+        id: string;
+        content?: string | undefined;
+        importance?: number | undefined;
+        replacement_id?: string | undefined;
+    }, {}>;
     readonly strict = true;
     readonly loadMode = "discoverable";
     readonly summary = "Update, forget, or invalidate Mnemopi memories";

package/dist/types/tools/memory-recall.d.ts

@@ -1,19 +1,18 @@
 import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import { z } from "zod/v4";
 import type { ToolSession } from ".";
-declare const memoryRecallSchema: z.ZodObject<{
-    query: z.ZodString;
-}, z.core.$strip>;
-export type MemoryRecallParams = z.infer<typeof memoryRecallSchema>;
+declare const memoryRecallSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    query: string;
+}, {}>;
+export type MemoryRecallParams = typeof memoryRecallSchema.infer;
 export declare class MemoryRecallTool implements AgentTool<typeof memoryRecallSchema> {
     private readonly session;
     readonly name = "recall";
     readonly approval: "read";
     readonly label = "Recall";
     readonly description: string;
-    readonly parameters: z.ZodObject<{
-        query: z.ZodString;
-    }, z.core.$strip>;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        query: string;
+    }, {}>;
     readonly strict = true;
     readonly loadMode = "discoverable";
     readonly summary = "Search memory for relevant prior context";

package/dist/types/tools/memory-reflect.d.ts

@@ -1,21 +1,20 @@
 import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import { z } from "zod/v4";
 import type { ToolSession } from ".";
-declare const memoryReflectSchema: z.ZodObject<{
-    query: z.ZodString;
-    context: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type MemoryReflectParams = z.infer<typeof memoryReflectSchema>;
+declare const memoryReflectSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    query: string;
+    context?: string | undefined;
+}, {}>;
+export type MemoryReflectParams = typeof memoryReflectSchema.infer;
 export declare class MemoryReflectTool implements AgentTool<typeof memoryReflectSchema> {
     private readonly session;
     readonly name = "reflect";
     readonly approval: "read";
     readonly label = "Reflect";
     readonly description: string;
-    readonly parameters: z.ZodObject<{
-        query: z.ZodString;
-        context: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        query: string;
+        context?: string | undefined;
+    }, {}>;
     readonly strict = true;
     readonly loadMode = "discoverable";
     readonly summary = "Synthesize an answer from long-term memory";

package/dist/types/tools/memory-retain.d.ts

@@ -1,25 +1,24 @@
 import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import { z } from "zod/v4";
 import type { ToolSession } from ".";
-declare const memoryRetainSchema: z.ZodObject<{
-    items: z.ZodArray<z.ZodObject<{
-        content: z.ZodString;
-        context: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type MemoryRetainParams = z.infer<typeof memoryRetainSchema>;
+declare const memoryRetainSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    items: {
+        content: string;
+        context?: string | undefined;
+    }[];
+}, {}>;
+export type MemoryRetainParams = typeof memoryRetainSchema.infer;
 export declare class MemoryRetainTool implements AgentTool<typeof memoryRetainSchema> {
     private readonly session;
     readonly name = "retain";
     readonly approval: "read";
     readonly label = "Retain";
     readonly description: string;
-    readonly parameters: z.ZodObject<{
-        items: z.ZodArray<z.ZodObject<{
-            content: z.ZodString;
-            context: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        items: {
+            content: string;
+            context?: string | undefined;
+        }[];
+    }, {}>;
     readonly strict = true;
     readonly loadMode = "discoverable";
     readonly summary = "Store important facts in long-term memory";

package/dist/types/tools/read.d.ts

@@ -1,15 +1,14 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
-import { z } from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme } from "../modes/theme/theme";
 import type { ToolSession } from "../sdk";
 import { type TruncationResult } from "../session/streaming-output";
 import { type OutputMeta } from "./output-meta";
-declare const readSchema: z.ZodObject<{
-    path: z.ZodString;
-}, z.core.$strict>;
-export type ReadToolInput = z.infer<typeof readSchema>;
+declare const readSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    path: string;
+}, {}>;
+export type ReadToolInput = typeof readSchema.infer;
 export interface ReadToolDetails {
     kind?: "file" | "url";
     truncation?: TruncationResult;
@@ -58,9 +57,9 @@ export declare class ReadTool implements AgentTool<typeof readSchema, ReadToolDe
     readonly label = "Read";
     readonly loadMode = "essential";
     readonly description: string;
-    readonly parameters: z.ZodObject<{
-        path: z.ZodString;
-    }, z.core.$strict>;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        path: string;
+    }, {}>;
     readonly strict = true;
     constructor(session: ToolSession);
     execute(_toolCallId: string, params: ReadParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<ReadToolDetails>, _toolContext?: AgentToolContext): Promise<AgentToolResult<ReadToolDetails>>;

package/dist/types/tools/resolve.d.ts

@@ -1,18 +1,14 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
-import { z } from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import type { ToolSession } from ".";
-declare const resolveSchema: z.ZodObject<{
-    action: z.ZodEnum<{
-        apply: "apply";
-        discard: "discard";
-    }>;
-    reason: z.ZodString;
-    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>;
-type ResolveParams = z.infer<typeof resolveSchema>;
+declare const resolveSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    action: "apply" | "discard";
+    reason: string;
+    extra?: Record<string, unknown> | undefined;
+}, {}>;
+type ResolveParams = typeof resolveSchema.infer;
 export interface ResolveToolDetails {
     action: "apply" | "discard";
     reason: string;
@@ -62,14 +58,11 @@ export declare class ResolveTool implements AgentTool<typeof resolveSchema, Reso
     readonly label = "Resolve";
     readonly hidden = true;
     readonly description: string;
-    readonly parameters: z.ZodObject<{
-        action: z.ZodEnum<{
-            apply: "apply";
-            discard: "discard";
-        }>;
-        reason: z.ZodString;
-        extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        action: "apply" | "discard";
+        reason: string;
+        extra?: Record<string, unknown> | undefined;
+    }, {}>;
     readonly strict = true;
     readonly intent: (args: Partial<ResolveParams>) => string;
     constructor(session: ToolSession);

package/dist/types/tools/review.d.ts

@@ -6,7 +6,6 @@
  * Reviewers finish via `yield` tool with SubmitReviewDetails schema.
  */
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
-import { z } from "zod/v4";
 import type { Theme, ThemeColor } from "../modes/theme/theme";
 import type { ReviewFinding } from "../task/types";
 export type FindingPriority = "P0" | "P1" | "P2" | "P3";
@@ -17,20 +16,15 @@ export interface FindingPriorityInfo {
 }
 export declare const PRIORITY_LABELS: FindingPriority[];
 export declare function getPriorityInfo(priority: FindingPriority): FindingPriorityInfo;
-declare const ReportFindingParams: z.ZodObject<{
-    title: z.ZodString;
-    body: z.ZodString;
-    priority: z.ZodEnum<{
-        P0: "P0";
-        P1: "P1";
-        P2: "P2";
-        P3: "P3";
-    }>;
-    confidence: z.ZodNumber;
-    file_path: z.ZodString;
-    line_start: z.ZodNumber;
-    line_end: z.ZodNumber;
-}, z.core.$strict>;
+declare const ReportFindingParams: import("arktype/internal/variants/object.ts").ObjectType<{
+    title: string;
+    body: string;
+    priority: "P0" | "P1" | "P2" | "P3";
+    confidence: number;
+    file_path: string;
+    line_start: number;
+    line_end: number;
+}, {}>;
 interface ReportFindingDetails {
     title: string;
     body: string;

package/dist/types/tools/search-tool-bm25.d.ts

@@ -1,15 +1,14 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
-import { z } from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import { type DiscoverableTool } from "../tool-discovery/tool-index";
 import type { ToolSession } from ".";
-declare const searchToolBm25Schema: z.ZodObject<{
-    query: z.ZodString;
-    limit: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-type SearchToolBm25Params = z.infer<typeof searchToolBm25Schema>;
+declare const searchToolBm25Schema: import("arktype/internal/variants/object.ts").ObjectType<{
+    query: string;
+    limit?: number | undefined;
+}, {}>;
+type SearchToolBm25Params = typeof searchToolBm25Schema.infer;
 interface SearchToolBm25Match {
     name: string;
     label: string;
@@ -41,10 +40,10 @@ export declare class SearchToolBm25Tool implements AgentTool<typeof searchToolBm
     readonly label = "SearchTools";
     readonly loadMode = "essential";
     get description(): string;
-    readonly parameters: z.ZodObject<{
-        query: z.ZodString;
-        limit: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        query: string;
+        limit?: number | undefined;
+    }, {}>;
     readonly strict = true;
     constructor(session: ToolSession);
     static createIf(session: ToolSession): SearchToolBm25Tool | null;