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

package/dist/types/session/agent-session.d.ts

@@ -297,6 +297,16 @@ export interface RoleModelCycle {
     models: ResolvedRoleModel[];
     currentIndex: number;
 }
+export interface ContextUsageBreakdown {
+    contextWindow: number;
+    anchored: boolean;
+    usedTokens: number;
+    systemPromptTokens: number;
+    systemToolsTokens: number;
+    systemContextTokens: number;
+    skillsTokens: number;
+    messagesTokens: number;
+}
 /** Session statistics for /session command */
 export interface SessionStats {
     sessionFile: string | undefined;
@@ -1066,6 +1076,10 @@ export declare class AgentSession {
         selectedText: string;
         cancelled: boolean;
     }>;
+    branchFromBtw(question: string, assistantMessage: AssistantMessage): Promise<{
+        cancelled: boolean;
+        sessionFile: string | undefined;
+    }>;
     /**
      * Navigate to a different node in the session tree.
      * Unlike branch() which creates a new session file, this stays in the same file.
@@ -1102,9 +1116,19 @@ export declare class AgentSession {
      * Uses the last assistant message's usage data when available,
      * otherwise estimates tokens for all messages.
      */
+    getContextBreakdown(options?: {
+        contextWindow?: number;
+        pendingMessages?: AgentMessage[];
+    }): ContextUsageBreakdown | undefined;
     getContextUsage(options?: {
         contextWindow?: number;
     }): ContextUsage | undefined;
+    /**
+     * Monotonic counter that changes whenever the in-flight pending context
+     * snapshot is set or cleared. Status-line context memoization keys on this so
+     * a value computed mid-turn cannot persist after the turn ends/aborts.
+     */
+    get contextUsageRevision(): number;
     fetchUsageReports(signal?: AbortSignal): Promise<UsageReport[] | null>;
     /**
      * Redeem one saved Codex rate-limit reset for a specific account, injecting

package/dist/types/session/session-persistence.d.ts

@@ -5,4 +5,8 @@ export declare function isImageBlock(value: unknown): value is {
     data: string;
     mimeType?: string;
 };
+export declare function isImageDataPayload(value: unknown): value is {
+    data: string;
+    mimeType?: string;
+};
 export declare function prepareEntryForPersistence(entry: FileEntry, blobStore: BlobStore): FileEntry;

package/dist/types/startup-splash.d.ts

@@ -0,0 +1,12 @@
+/** Inputs used to decide whether the optional startup splash may run for this process. */
+export interface StartupSplashDecisionOptions {
+    readonly configured: boolean;
+    readonly isInteractive: boolean;
+    readonly resuming: boolean;
+    readonly quiet: boolean;
+    readonly timing: boolean;
+    readonly stdinIsTTY: boolean | undefined;
+    readonly stdoutIsTTY: boolean | undefined;
+}
+/** Returns true only for explicitly enabled, normal interactive TTY startup. */
+export declare function shouldShowStartupSplash(options: StartupSplashDecisionOptions): boolean;

package/dist/types/task/types.d.ts

@@ -1,6 +1,5 @@
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Usage } from "@oh-my-pi/pi-ai";
-import { z } from "zod/v4";
 import type { AgentSessionEvent } from "../session/agent-session";
 import type { NestedRepoPatch } from "./worktree";
 /** Source of an agent definition */
@@ -55,12 +54,12 @@ export interface SubagentLifecyclePayload {
 export declare const ROLE_LABEL_MAX = 80;
 /** Schema bound on the raw `role` input, before it is label-normalized at every use site. */
 export declare const ROLE_INPUT_MAX = 256;
-export declare const taskItemSchema: z.ZodObject<{
-    id: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodString>;
-    role: z.ZodOptional<z.ZodString>;
-    assignment: z.ZodString;
-}, z.core.$strip>;
+export declare const taskItemSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    id?: string | undefined;
+    description?: string | undefined;
+    role?: string | undefined;
+    assignment: string;
+}, {}>;
 /** Single task item. Fields are optional defensively: args stream in token by token. */
 export interface TaskItem {
     /** Stable agent id; default = generated AdjectiveNoun. */
@@ -74,47 +73,47 @@ export interface TaskItem {
     /** Run this spawn in an isolated worktree (batch form; flat form carries it top-level). */
     isolated?: boolean;
 }
-export declare const taskSchema: z.ZodObject<{
-    id: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodString>;
-    role: z.ZodOptional<z.ZodString>;
-    assignment: z.ZodString;
-    isolated: z.ZodOptional<z.ZodBoolean>;
-    agent: z.ZodString;
-}, z.core.$strip>;
-declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
-    id: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodString>;
-    role: z.ZodOptional<z.ZodString>;
-    assignment: z.ZodString;
-    isolated: z.ZodOptional<z.ZodBoolean>;
-    agent: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    id: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodString>;
-    role: z.ZodOptional<z.ZodString>;
-    assignment: z.ZodString;
-    agent: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    agent: z.ZodString;
-    context: z.ZodString;
-    tasks: z.ZodArray<z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        description: z.ZodOptional<z.ZodString>;
-        role: z.ZodOptional<z.ZodString>;
-        assignment: z.ZodString;
-        isolated: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-}, z.core.$strip>, z.ZodObject<{
-    agent: z.ZodString;
-    context: z.ZodString;
-    tasks: z.ZodArray<z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        description: z.ZodOptional<z.ZodString>;
-        role: z.ZodOptional<z.ZodString>;
-        assignment: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>];
+export declare const taskSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    agent: string;
+    id?: string | undefined;
+    description?: string | undefined;
+    role?: string | undefined;
+    assignment: string;
+    isolated?: boolean | undefined;
+}, {}>;
+declare const ALL_TASK_SCHEMAS: readonly [import("arktype/internal/variants/object.ts").ObjectType<{
+    agent: string;
+    id?: string | undefined;
+    description?: string | undefined;
+    role?: string | undefined;
+    assignment: string;
+    isolated?: boolean | undefined;
+}, {}>, import("arktype/internal/variants/object.ts").ObjectType<{
+    agent: string;
+    id?: string | undefined;
+    description?: string | undefined;
+    role?: string | undefined;
+    assignment: string;
+}, {}>, import("arktype/internal/variants/object.ts").ObjectType<{
+    agent: string;
+    context: string;
+    tasks: {
+        id?: string | undefined;
+        description?: string | undefined;
+        role?: string | undefined;
+        assignment: string;
+        isolated?: boolean | undefined;
+    }[];
+}, {}>, import("arktype/internal/variants/object.ts").ObjectType<{
+    agent: string;
+    context: string;
+    tasks: {
+        id?: string | undefined;
+        description?: string | undefined;
+        role?: string | undefined;
+        assignment: string;
+    }[];
+}, {}>];
 type DynamicTaskSchema = (typeof ALL_TASK_SCHEMAS)[number];
 export type TaskSchema = typeof taskSchema;
 /** Active task tool parameter schema for the current isolation / batch flags */

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

@@ -17,23 +17,22 @@
 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 { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme } from "../modes/theme/theme";
 import type { ToolSession } from ".";
-declare const askSchema: z.ZodObject<{
-    questions: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        question: z.ZodString;
-        options: z.ZodArray<z.ZodObject<{
-            label: z.ZodString;
-            description: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        multi: z.ZodOptional<z.ZodBoolean>;
-        recommended: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type AskToolInput = z.infer<typeof askSchema>;
+declare const askSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    questions: {
+        id: string;
+        question: string;
+        options: {
+            label: string;
+            description?: string | undefined;
+        }[];
+        multi?: boolean | undefined;
+        recommended?: number | undefined;
+    }[];
+}, {}>;
+export type AskToolInput = typeof askSchema.infer;
 /** Result for a single question */
 export interface QuestionResult {
     id: string;
@@ -71,20 +70,20 @@ export declare class AskTool implements AgentTool<typeof askSchema, AskToolDetai
     readonly label = "Ask";
     readonly summary = "Ask the user a clarifying question";
     readonly description: string;
-    readonly parameters: z.ZodObject<{
-        questions: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            question: z.ZodString;
-            options: z.ZodArray<z.ZodObject<{
-                label: z.ZodString;
-                description: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>;
-            multi: z.ZodOptional<z.ZodBoolean>;
-            recommended: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        questions: {
+            id: string;
+            question: string;
+            options: {
+                label: string;
+                description?: string | undefined;
+            }[];
+            multi?: boolean | undefined;
+            recommended?: number | undefined;
+        }[];
+    }, {}>;
     readonly strict = true;
-    readonly examples: readonly ToolExample<z.input<typeof askSchema>>[];
+    readonly examples: readonly ToolExample<typeof askSchema.infer>[];
     readonly concurrency = "exclusive";
     readonly loadMode = "discoverable";
     constructor(session: ToolSession);

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

@@ -1,18 +1,17 @@
 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 { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import type { ToolSession } from ".";
 import type { OutputMeta } from "./output-meta";
-declare const astEditSchema: z.ZodObject<{
-    ops: z.ZodArray<z.ZodObject<{
-        pat: z.ZodString;
-        out: z.ZodString;
-    }, z.core.$strip>>;
-    paths: z.ZodArray<z.ZodString>;
-}, z.core.$strip>;
+declare const astEditSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    ops: {
+        pat: string;
+        out: string;
+    }[];
+    paths: string[];
+}, {}>;
 export interface AstEditToolDetails {
     totalReplacements: number;
     filesTouched: number;
@@ -39,6 +38,7 @@ export interface AstEditToolDetails {
      * renderer resolves them against this; `searchPath` is the scope target. */
     cwd?: string;
 }
+type AstEditSchemaInfer = typeof astEditSchema.infer;
 export declare class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolDetails> {
     private readonly session;
     readonly name = "ast_edit";
@@ -47,19 +47,19 @@ export declare class AstEditTool implements AgentTool<typeof astEditSchema, AstE
     readonly label = "AST Edit";
     readonly summary = "Perform AST-aware code edits (structural refactoring)";
     readonly description: string;
-    readonly parameters: z.ZodObject<{
-        ops: z.ZodArray<z.ZodObject<{
-            pat: z.ZodString;
-            out: z.ZodString;
-        }, z.core.$strip>>;
-        paths: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        ops: {
+            pat: string;
+            out: string;
+        }[];
+        paths: string[];
+    }, {}>;
     readonly strict = true;
-    readonly examples: readonly ToolExample<z.input<typeof astEditSchema>>[];
+    readonly examples: readonly ToolExample<AstEditSchemaInfer>[];
     readonly deferrable = true;
     readonly loadMode = "discoverable";
     constructor(session: ToolSession);
-    execute(_toolCallId: string, params: z.infer<typeof astEditSchema>, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<AstEditToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<AstEditToolDetails>>;
+    execute(_toolCallId: string, params: AstEditSchemaInfer, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<AstEditToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<AstEditToolDetails>>;
 }
 interface AstEditRenderArgs {
     ops?: Array<{

package/dist/types/tools/ast-grep.d.ts

@@ -1,16 +1,15 @@
 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 { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import type { ToolSession } from ".";
 import type { OutputMeta } from "./output-meta";
-declare const astGrepSchema: z.ZodObject<{
-    pat: z.ZodString;
-    paths: z.ZodArray<z.ZodString>;
-    skip: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
-}, z.core.$strip>;
+declare const astGrepSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    pat: string;
+    paths: string[];
+    skip?: number | undefined;
+}, {}>;
 export interface AstGrepToolDetails {
     matchCount: number;
     fileCount: number;
@@ -43,16 +42,16 @@ export declare class AstGrepTool implements AgentTool<typeof astGrepSchema, AstG
     readonly label = "AST Grep";
     readonly summary = "Search code with AST patterns (structural grep)";
     readonly description: string;
-    readonly parameters: z.ZodObject<{
-        pat: z.ZodString;
-        paths: z.ZodArray<z.ZodString>;
-        skip: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
-    }, z.core.$strip>;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        pat: string;
+        paths: string[];
+        skip?: number | undefined;
+    }, {}>;
     readonly strict = true;
-    readonly examples: readonly ToolExample<z.input<typeof astGrepSchema>>[];
+    readonly examples: readonly ToolExample<typeof astGrepSchema.inferIn>[];
     readonly loadMode = "discoverable";
     constructor(session: ToolSession);
-    execute(_toolCallId: string, params: z.infer<typeof astGrepSchema>, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<AstGrepToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<AstGrepToolDetails>>;
+    execute(_toolCallId: string, params: typeof astGrepSchema.infer, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<AstGrepToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<AstGrepToolDetails>>;
 }
 interface AstGrepRenderArgs {
     pat?: string;

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

@@ -1,6 +1,5 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback, ToolApprovalDecision } 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 ".";
@@ -14,21 +13,25 @@ export declare const BASH_DEFAULT_PREVIEW_LINES = 10;
  * New patterns should target shapes that are virtually never legitimate in automation.
  */
 export declare const CRITICAL_BASH_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp];
-declare const bashSchemaBase: z.ZodObject<{
-    command: z.ZodString;
-    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    timeout: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
-    cwd: z.ZodOptional<z.ZodString>;
-    pty: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-declare const bashSchemaWithAsync: z.ZodObject<{
-    command: z.ZodString;
-    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    timeout: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
-    cwd: z.ZodOptional<z.ZodString>;
-    pty: z.ZodOptional<z.ZodBoolean>;
-    async: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
+declare const bashSchemaBase: import("arktype/internal/variants/object.ts").ObjectType<{
+    command: string;
+    env?: {
+        [x: string]: string;
+    } | undefined;
+    timeout?: number | undefined;
+    cwd?: string | undefined;
+    pty?: boolean | undefined;
+}, {}>;
+declare const bashSchemaWithAsync: import("arktype/internal/variants/object.ts").ObjectType<{
+    command: string;
+    env?: {
+        [x: string]: string;
+    } | undefined;
+    timeout?: number | undefined;
+    cwd?: string | undefined;
+    pty?: boolean | undefined;
+    async?: boolean | undefined;
+}, {}>;
 type BashToolSchema = typeof bashSchemaBase | typeof bashSchemaWithAsync;
 export interface BashToolInput {
     command: string;
@@ -59,7 +62,7 @@ export interface BashToolOptions {
  *
  * Executes bash commands with optional timeout and working directory.
  */
-export declare class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
+export declare class BashTool implements AgentTool<typeof bashSchemaBase | typeof bashSchemaWithAsync, BashToolDetails> {
     #private;
     private readonly session;
     readonly name = "bash";

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

@@ -1,6 +1,5 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { ToolExample } from "@oh-my-pi/pi-ai";
-import { z } from "zod/v4";
 import type { ToolSession } from "../sdk";
 import { type BrowserKindTag } from "./browser/registry";
 import type { Observation, ScreenshotResult } from "./browser/tab-protocol";
@@ -9,42 +8,30 @@ export { cmuxSnapshotToObservation, mapWaitUntil, resolveCmuxKind, serializeEval
 export { CmuxSocketClient } from "./browser/cmux/socket-client";
 export { extractReadableFromHtml, type ReadableFormat, type ReadableResult } from "./browser/readable";
 export type { Observation, ObservationEntry } from "./browser/tab-protocol";
-declare const browserSchema: z.ZodObject<{
-    action: z.ZodEnum<{
-        close: "close";
-        open: "open";
-        run: "run";
-    }>;
-    name: z.ZodOptional<z.ZodString>;
-    url: z.ZodOptional<z.ZodString>;
-    app: z.ZodOptional<z.ZodObject<{
-        path: z.ZodOptional<z.ZodString>;
-        cdp_url: z.ZodOptional<z.ZodString>;
-        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        target: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    viewport: z.ZodOptional<z.ZodObject<{
-        width: z.ZodNumber;
-        height: z.ZodNumber;
-        scale: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    wait_until: z.ZodOptional<z.ZodEnum<{
-        domcontentloaded: "domcontentloaded";
-        load: "load";
-        networkidle0: "networkidle0";
-        networkidle2: "networkidle2";
-    }>>;
-    dialogs: z.ZodOptional<z.ZodEnum<{
-        accept: "accept";
-        dismiss: "dismiss";
-    }>>;
-    code: z.ZodOptional<z.ZodString>;
-    timeout: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
-    all: z.ZodOptional<z.ZodBoolean>;
-    kill: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
+declare const browserSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    action: "close" | "open" | "run";
+    name?: string | undefined;
+    url?: string | undefined;
+    app?: {
+        path?: string | undefined;
+        cdp_url?: string | undefined;
+        args?: string[] | undefined;
+        target?: string | undefined;
+    } | undefined;
+    viewport?: {
+        width: number;
+        height: number;
+        scale?: number | undefined;
+    } | undefined;
+    wait_until?: "domcontentloaded" | "load" | "networkidle0" | "networkidle2" | undefined;
+    dialogs?: "accept" | "dismiss" | undefined;
+    code?: string | undefined;
+    timeout?: number | undefined;
+    all?: boolean | undefined;
+    kill?: boolean | undefined;
+}, {}>;
 /** Input schema for the browser tool. */
-export type BrowserParams = z.infer<typeof browserSchema>;
+export type BrowserParams = typeof browserSchema.infer;
 /** Details describing a browser tool execution result (for renderers + transcript). */
 export interface BrowserToolDetails {
     action: BrowserParams["action"];
@@ -76,42 +63,30 @@ export declare class BrowserTool implements AgentTool<typeof browserSchema, Brow
     readonly label = "Browser";
     readonly loadMode = "discoverable";
     readonly summary = "Control a headless browser to navigate and interact with web pages";
-    readonly parameters: z.ZodObject<{
-        action: z.ZodEnum<{
-            close: "close";
-            open: "open";
-            run: "run";
-        }>;
-        name: z.ZodOptional<z.ZodString>;
-        url: z.ZodOptional<z.ZodString>;
-        app: z.ZodOptional<z.ZodObject<{
-            path: z.ZodOptional<z.ZodString>;
-            cdp_url: z.ZodOptional<z.ZodString>;
-            args: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            target: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        viewport: z.ZodOptional<z.ZodObject<{
-            width: z.ZodNumber;
-            height: z.ZodNumber;
-            scale: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-        wait_until: z.ZodOptional<z.ZodEnum<{
-            domcontentloaded: "domcontentloaded";
-            load: "load";
-            networkidle0: "networkidle0";
-            networkidle2: "networkidle2";
-        }>>;
-        dialogs: z.ZodOptional<z.ZodEnum<{
-            accept: "accept";
-            dismiss: "dismiss";
-        }>>;
-        code: z.ZodOptional<z.ZodString>;
-        timeout: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
-        all: z.ZodOptional<z.ZodBoolean>;
-        kill: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        action: "close" | "open" | "run";
+        name?: string | undefined;
+        url?: string | undefined;
+        app?: {
+            path?: string | undefined;
+            cdp_url?: string | undefined;
+            args?: string[] | undefined;
+            target?: string | undefined;
+        } | undefined;
+        viewport?: {
+            width: number;
+            height: number;
+            scale?: number | undefined;
+        } | undefined;
+        wait_until?: "domcontentloaded" | "load" | "networkidle0" | "networkidle2" | undefined;
+        dialogs?: "accept" | "dismiss" | undefined;
+        code?: string | undefined;
+        timeout?: number | undefined;
+        all?: boolean | undefined;
+        kill?: boolean | undefined;
+    }, {}>;
     readonly strict = true;
-    readonly examples: readonly ToolExample<z.input<typeof browserSchema>>[];
+    readonly examples: readonly ToolExample<typeof browserSchema.infer>[];
     constructor(session: ToolSession);
     get description(): string;
     /** Restart browser to apply mode changes (e.g. headless toggle). Drops only headless browsers. */

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

@@ -1,5 +1,4 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import { z } from "zod/v4";
 import type { ToolSession } from ".";
 import type { OutputMeta } from "./output-meta";
 export interface CheckpointState {
@@ -10,14 +9,14 @@ export interface CheckpointState {
     /** Timestamp */
     startedAt: string;
 }
-declare const checkpointSchema: z.ZodObject<{
-    goal: z.ZodString;
-}, z.core.$strip>;
-type CheckpointParams = z.infer<typeof checkpointSchema>;
-declare const rewindSchema: z.ZodObject<{
-    report: z.ZodString;
-}, z.core.$strip>;
-type RewindParams = z.infer<typeof rewindSchema>;
+declare const checkpointSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    goal: string;
+}, {}>;
+type CheckpointParams = typeof checkpointSchema.infer;
+declare const rewindSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    report: string;
+}, {}>;
+type RewindParams = typeof rewindSchema.infer;
 export interface CheckpointToolDetails {
     goal: string;
     startedAt: string;
@@ -35,9 +34,9 @@ export declare class CheckpointTool implements AgentTool<typeof checkpointSchema
     readonly label = "Checkpoint";
     readonly summary = "Create a git-based checkpoint to save and restore session state";
     readonly description: string;
-    readonly parameters: z.ZodObject<{
-        goal: z.ZodString;
-    }, z.core.$strip>;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        goal: string;
+    }, {}>;
     readonly strict = true;
     readonly loadMode = "discoverable";
     readonly intent: (args: Partial<CheckpointParams>) => string;
@@ -52,9 +51,9 @@ export declare class RewindTool implements AgentTool<typeof rewindSchema, Rewind
     readonly label = "Rewind";
     readonly summary = "Rewind to a previously created checkpoint";
     readonly description: string;
-    readonly parameters: z.ZodObject<{
-        report: z.ZodString;
-    }, z.core.$strip>;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        report: string;
+    }, {}>;
     readonly strict = true;
     readonly loadMode = "discoverable";
     readonly intent: () => string;