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

package/dist/types/advisor/advise-tool.d.ts

@@ -1,14 +1,9 @@
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import { z } from "zod/v4";
-declare const adviseSchema: z.ZodObject<{
-    note: z.ZodString;
-    severity: z.ZodOptional<z.ZodEnum<{
-        blocker: "blocker";
-        concern: "concern";
-        nit: "nit";
-    }>>;
-}, z.core.$strip>;
-export type AdviseParams = z.infer<typeof adviseSchema>;
+import type { AgentIdentity, AgentTelemetryConfig, AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+declare const adviseSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    note: string;
+    severity?: "blocker" | "concern" | "nit" | undefined;
+}, {}>;
+export type AdviseParams = typeof adviseSchema.infer;
 export type AdvisorSeverity = "nit" | "concern" | "blocker";
 export interface AdviseDetails {
     note: string;
@@ -39,6 +34,12 @@ export declare function formatAdvisorBatchContent(notes: readonly AdvisorNote[])
 export declare function isInterruptingSeverity(severity: AdvisorSeverity | undefined): boolean;
 /** How an advisor note is routed to the primary. */
 export type AdvisorDeliveryChannel = "aside" | "steer" | "preserve";
+/** Half-open turn-count fence for the post-interrupt cooldown. */
+export declare function isAdvisorInterruptImmuneTurnActive(opts: {
+    completedTurns: number;
+    immuneTurnStart: number | undefined;
+    immuneTurns: number;
+}): boolean;
 /**
  * Decide how one advisor note reaches the primary agent.
  *
@@ -54,13 +55,28 @@ export type AdvisorDeliveryChannel = "aside" | "steer" | "preserve";
  *   auto-resume anything, so it is delivered live. Parking it during an active
  *   run instead strands it (it never reaches the running agent) and the withheld
  *   notes dump as one burst at the next user prompt — the bug this guards.
+ * - During the post-interrupt immune-turn window, further `concern`/`blocker`
+ *   notes are downgraded to asides; suppression preservation still wins.
  */
 export declare function resolveAdvisorDeliveryChannel(opts: {
     severity: AdvisorSeverity | undefined;
     autoResumeSuppressed: boolean;
     streaming: boolean;
     aborting: boolean;
+    interruptImmuneTurnActive?: boolean;
 }): AdvisorDeliveryChannel;
+/**
+ * Derive the advisor loop's telemetry from the primary session's config so the
+ * advisor model's GenAI spans and usage/cost hooks (onChatUsage, onCostDelta,
+ * costEstimator) fire under the same pipeline as every other model call —
+ * stamped with the advisor's own agent identity. `conversationId` is cleared so
+ * the advisor loop falls back to its own `-advisor` session id for
+ * `gen_ai.conversation.id` instead of inheriting the primary's conversation.
+ *
+ * Returns undefined when the primary has no telemetry (instrumentation off), so
+ * the advisor `Agent` stays a zero-overhead no-op as well.
+ */
+export declare function deriveAdvisorTelemetry(primaryTelemetry: AgentTelemetryConfig | undefined, identity: AgentIdentity): AgentTelemetryConfig | undefined;
 /**
  * Side-effect-free investigation tools handed to the advisor agent so it can
  * inspect the workspace before weighing in. Names match the primary session's
@@ -72,14 +88,10 @@ export declare class AdviseTool implements AgentTool<typeof adviseSchema, Advise
     readonly name = "advise";
     readonly label = "Advise";
     readonly description: string;
-    readonly parameters: z.ZodObject<{
-        note: z.ZodString;
-        severity: z.ZodOptional<z.ZodEnum<{
-            blocker: "blocker";
-            concern: "concern";
-            nit: "nit";
-        }>>;
-    }, z.core.$strip>;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        note: string;
+        severity?: "blocker" | "concern" | "nit" | undefined;
+    }, {}>;
     readonly intent: "omit";
     constructor(onAdvice: (note: string, severity?: AdviseDetails["severity"]) => void);
     execute(_toolCallId: string, args: AdviseParams, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<AdviseDetails>, _context?: AgentToolContext): Promise<AgentToolResult<AdviseDetails>>;

package/dist/types/autoresearch/tools/init-experiment.d.ts

@@ -1,24 +1,20 @@
-import { z } from "zod/v4";
 import type { ToolDefinition } from "../../extensibility/extensions";
 import type { AutoresearchToolFactoryOptions, ExperimentState } from "../types";
 export declare const HARNESS_FILENAME = "autoresearch.sh";
 export declare const DEFAULT_HARNESS_COMMAND = "bash autoresearch.sh";
-declare const initExperimentSchema: z.ZodObject<{
-    name: z.ZodString;
-    goal: z.ZodOptional<z.ZodString>;
-    primary_metric: z.ZodString;
-    metric_unit: z.ZodOptional<z.ZodString>;
-    direction: z.ZodOptional<z.ZodEnum<{
-        higher: "higher";
-        lower: "lower";
-    }>>;
-    secondary_metrics: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    scope_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    off_limits: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    max_iterations: z.ZodOptional<z.ZodNumber>;
-    new_segment: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
+declare const initExperimentSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    name: string;
+    goal?: string | undefined;
+    primary_metric: string;
+    metric_unit?: string | undefined;
+    direction?: "higher" | "lower" | undefined;
+    secondary_metrics?: string[] | undefined;
+    scope_paths?: string[] | undefined;
+    off_limits?: string[] | undefined;
+    constraints?: string[] | undefined;
+    max_iterations?: number | undefined;
+    new_segment?: boolean | undefined;
+}, {}>;
 interface InitExperimentDetails {
     state: ExperimentState;
     createdSession: boolean;

package/dist/types/autoresearch/tools/log-experiment.d.ts

@@ -1,23 +1,21 @@
-import { z } from "zod/v4";
 import type { ToolDefinition } from "../../extensibility/extensions";
 import type { AutoresearchToolFactoryOptions, LogDetails } from "../types";
-declare const logExperimentSchema: z.ZodObject<{
-    metric: z.ZodNumber;
-    status: z.ZodEnum<{
-        checks_failed: "checks_failed";
-        crash: "crash";
-        discard: "discard";
-        keep: "keep";
-    }>;
-    description: z.ZodString;
-    metrics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
-    asi: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
-    commit: z.ZodOptional<z.ZodString>;
-    justification: z.ZodOptional<z.ZodString>;
-    flag_runs: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        run_id: z.ZodNumber;
-        reason: z.ZodString;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
+declare const logExperimentSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    metric: number;
+    status: "checks_failed" | "crash" | "discard" | "keep";
+    description: string;
+    metrics?: {
+        [x: string]: number;
+    } | undefined;
+    asi?: {
+        [x: string]: unknown;
+    } | undefined;
+    commit?: string | undefined;
+    justification?: string | undefined;
+    flag_runs?: {
+        run_id: number;
+        reason: string;
+    }[] | undefined;
+}, {}>;
 export declare function createLogExperimentTool(options: AutoresearchToolFactoryOptions): ToolDefinition<typeof logExperimentSchema, LogDetails>;
 export {};

package/dist/types/autoresearch/tools/run-experiment.d.ts

@@ -1,8 +1,7 @@
-import { z } from "zod/v4";
 import type { ToolDefinition } from "../../extensibility/extensions";
 import type { AutoresearchToolFactoryOptions, RunDetails, RunExperimentProgressDetails } from "../types";
-declare const runExperimentSchema: z.ZodObject<{
-    timeout_seconds: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
+declare const runExperimentSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    timeout_seconds?: number | undefined;
+}, {}>;
 export declare function createRunExperimentTool(options: AutoresearchToolFactoryOptions): ToolDefinition<typeof runExperimentSchema, RunDetails | RunExperimentProgressDetails>;
 export {};

package/dist/types/autoresearch/tools/update-notes.d.ts

@@ -1,10 +1,9 @@
-import { z } from "zod/v4";
 import type { ToolDefinition } from "../../extensibility/extensions";
 import type { AutoresearchToolFactoryOptions } from "../types";
-declare const updateNotesSchema: z.ZodObject<{
-    body: z.ZodString;
-    append_idea: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
+declare const updateNotesSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    body: string;
+    append_idea?: string | undefined;
+}, {}>;
 interface UpdateNotesDetails {
     notes: string;
 }

package/dist/types/cli/args.d.ts

@@ -14,6 +14,7 @@ export interface Args {
     smol?: string;
     slow?: string;
     plan?: string;
+    maxTime?: number;
     apiKey?: string;
     systemPrompt?: string;
     appendSystemPrompt?: string;

package/dist/types/cli/bench-cli.d.ts

@@ -73,6 +73,12 @@ export interface BenchDependencies {
     now?: () => number;
     stdoutIsTTY?: boolean;
 }
+/**
+ * Tokens/s over the generation window (duration minus TTFT) so queue/prefill
+ * latency does not dilute throughput. Falls back to total duration when the
+ * response arrived as a single chunk (TTFT ~ duration).
+ */
+export declare function computeTokensPerSecond(outputTokens: number, durationMs: number, ttftMs: number, deltaChunkCount: number): number;
 export declare function formatBenchTable(summary: BenchSummary): string;
 export declare function runBenchCommand(command: BenchCommandArgs, deps?: BenchDependencies): Promise<BenchSummary>;
 export {};

package/dist/types/cli/ttsr-cli.d.ts

@@ -0,0 +1,39 @@
+export type TtsrAction = "test" | "list" | "scan";
+export declare const TTSR_ACTIONS: TtsrAction[];
+export declare const TTSR_SOURCES: TtsrMatchSource[];
+export type TtsrMatchSource = "text" | "thinking" | "tool";
+export interface TtsrTestArgs {
+    /** Inline snippet text. */
+    snippet?: string;
+    /** Snippet file path, or `-` for stdin. */
+    file?: string;
+    /** Path to a rule markdown file to test in isolation (skips project loading). */
+    rule?: string;
+    /** TTSR match source; when omitted, inferred from --file (tool for source files, text otherwise). */
+    source?: TtsrMatchSource;
+    /** Tool name when `source === "tool"` (e.g. "edit", "write"). */
+    tool?: string;
+    /** Candidate file path used for scope/glob matching and AST language inference. */
+    filePath?: string;
+    /** Show every evaluated rule, not just triggered ones. */
+    verbose?: boolean;
+}
+export interface TtsrScanArgs {
+    /** Directory to glob and scan files in. */
+    directory?: string;
+    /** Path to a rule markdown file to test in isolation (skips project loading). */
+    rule?: string;
+    /** Respect gitignore files while discovering scan candidates. Defaults to true. */
+    gitignore?: boolean;
+    /** Maximum file size to scan in bytes; 0 disables the limit. */
+    maxBytes?: number;
+    /** Show details. */
+    verbose?: boolean;
+}
+export interface TtsrCommandArgs {
+    action: TtsrAction;
+    test?: TtsrTestArgs;
+    scan?: TtsrScanArgs;
+    json?: boolean;
+}
+export declare function runTtsrCommand(cmd: TtsrCommandArgs): Promise<void>;

package/dist/types/commands/launch.d.ts

@@ -127,6 +127,9 @@ export default class Index extends Command {
         "no-title": import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"boolean"> & {
             description: string;
         };
+        "max-time": import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
         "auto-approve": import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"boolean"> & {
             aliases: string[];
             description: string;

package/dist/types/commands/ttsr.d.ts

@@ -0,0 +1,57 @@
+/**
+ * `omp ttsr` — inspect and test Time-Traveling Stream Rules.
+ *
+ * `omp ttsr test` feeds a snippet (inline, --file, or stdin) through the real
+ * TTSR matching pipeline and reports which rules would trigger. `omp ttsr list`
+ * shows every TTSR-registered rule the current project/user config would load.
+ */
+import { Command } from "@oh-my-pi/pi-utils/cli";
+export default class Ttsr extends Command {
+    static description: string;
+    static args: {
+        action: import("@oh-my-pi/pi-utils/cli").ArgDescriptor & {
+            description: string;
+            required: false;
+            options: import("../cli/ttsr-cli").TtsrAction[];
+        };
+        snippet: import("@oh-my-pi/pi-utils/cli").ArgDescriptor & {
+            description: string;
+            required: false;
+        };
+    };
+    static flags: {
+        file: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        rule: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"string"> & {
+            char: string;
+            description: string;
+        };
+        source: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+            options: import("../cli/ttsr-cli").TtsrMatchSource[];
+        };
+        tool: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        path: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"string"> & {
+            char: string;
+            description: string;
+        };
+        verbose: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"boolean"> & {
+            char: string;
+            description: string;
+        };
+        json: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        "no-gitignore": import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        "max-bytes": import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"integer"> & {
+            description: string;
+        };
+    };
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/types/commit/agentic/tools/analyze-file.d.ts

@@ -1,13 +1,12 @@
-import { z } from "zod/v4";
 import type { CommitAgentState } from "../../../commit/agentic/state";
 import type { ModelRegistry } from "../../../config/model-registry";
 import type { Settings } from "../../../config/settings";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
 import type { AuthStorage } from "../../../session/auth-storage";
-declare const analyzeFileSchema: z.ZodObject<{
-    files: z.ZodArray<z.ZodString>;
-    goal: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
+declare const analyzeFileSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    files: string[];
+    goal?: string | undefined;
+}, {}>;
 export declare function createAnalyzeFileTool(options: {
     cwd: string;
     authStorage: AuthStorage;

package/dist/types/commit/agentic/tools/git-file-diff.d.ts

@@ -1,10 +1,9 @@
-import { z } from "zod/v4";
 import type { CommitAgentState } from "../../../commit/agentic/state";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
 export declare function getFilePriority(filename: string): number;
-declare const gitFileDiffSchema: z.ZodObject<{
-    files: z.ZodArray<z.ZodString>;
-    staged: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
+declare const gitFileDiffSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    files: string[];
+    staged?: boolean | undefined;
+}, {}>;
 export declare function createGitFileDiffTool(cwd: string, state: CommitAgentState): CustomTool<typeof gitFileDiffSchema>;
 export {};

package/dist/types/commit/agentic/tools/git-hunk.d.ts

@@ -1,9 +1,8 @@
-import { z } from "zod/v4";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
-declare const gitHunkSchema: z.ZodObject<{
-    file: z.ZodString;
-    hunks: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-    staged: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
+declare const gitHunkSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    file: string;
+    hunks?: number[] | undefined;
+    staged?: boolean | undefined;
+}, {}>;
 export declare function createGitHunkTool(cwd: string): CustomTool<typeof gitHunkSchema>;
 export {};

package/dist/types/commit/agentic/tools/git-overview.d.ts

@@ -1,9 +1,8 @@
-import { z } from "zod/v4";
 import type { CommitAgentState } from "../../../commit/agentic/state";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
-declare const gitOverviewSchema: z.ZodObject<{
-    staged: z.ZodOptional<z.ZodBoolean>;
-    include_untracked: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
+declare const gitOverviewSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    staged?: boolean | undefined;
+    include_untracked?: boolean | undefined;
+}, {}>;
 export declare function createGitOverviewTool(cwd: string, state: CommitAgentState): CustomTool<typeof gitOverviewSchema>;
 export {};

package/dist/types/commit/agentic/tools/propose-changelog.d.ts

@@ -1,28 +1,27 @@
-import { z } from "zod/v4";
 import type { CommitAgentState } from "../../../commit/agentic/state";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
-declare const proposeChangelogSchema: z.ZodObject<{
-    entries: z.ZodArray<z.ZodObject<{
-        path: z.ZodString;
-        entries: z.ZodObject<{
-            Added: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-            "Breaking Changes": z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-            Changed: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-            Deprecated: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-            Fixed: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-            Removed: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-            Security: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-        }, z.core.$strip>;
-        deletions: z.ZodOptional<z.ZodObject<{
-            Added: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-            "Breaking Changes": z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-            Changed: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-            Deprecated: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-            Fixed: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-            Removed: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-            Security: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+declare const proposeChangelogSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    entries: {
+        path: string;
+        entries: {
+            "Breaking Changes"?: string[] | undefined;
+            Added?: string[] | undefined;
+            Changed?: string[] | undefined;
+            Deprecated?: string[] | undefined;
+            Removed?: string[] | undefined;
+            Fixed?: string[] | undefined;
+            Security?: string[] | undefined;
+        };
+        deletions?: {
+            "Breaking Changes"?: string[] | undefined;
+            Added?: string[] | undefined;
+            Changed?: string[] | undefined;
+            Deprecated?: string[] | undefined;
+            Removed?: string[] | undefined;
+            Fixed?: string[] | undefined;
+            Security?: string[] | undefined;
+        } | undefined;
+    }[];
+}, {}>;
 export declare function createProposeChangelogTool(state: CommitAgentState, changelogTargets: string[]): CustomTool<typeof proposeChangelogSchema>;
 export {};

package/dist/types/commit/agentic/tools/propose-commit.d.ts

@@ -1,36 +1,15 @@
-import { z } from "zod/v4";
 import type { CommitAgentState } from "../../../commit/agentic/state";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
-declare const proposeCommitSchema: z.ZodObject<{
-    type: z.ZodEnum<{
-        build: "build";
-        chore: "chore";
-        ci: "ci";
-        docs: "docs";
-        feat: "feat";
-        fix: "fix";
-        perf: "perf";
-        refactor: "refactor";
-        revert: "revert";
-        style: "style";
-        test: "test";
-    }>;
-    scope: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
-    summary: z.ZodString;
-    details: z.ZodArray<z.ZodObject<{
-        text: z.ZodString;
-        changelog_category: z.ZodOptional<z.ZodEnum<{
-            Added: "Added";
-            "Breaking Changes": "Breaking Changes";
-            Changed: "Changed";
-            Deprecated: "Deprecated";
-            Fixed: "Fixed";
-            Removed: "Removed";
-            Security: "Security";
-        }>>;
-        user_visible: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    issue_refs: z.ZodArray<z.ZodString>;
-}, z.core.$strip>;
+declare const proposeCommitSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    type: "build" | "chore" | "ci" | "docs" | "feat" | "fix" | "perf" | "refactor" | "revert" | "style" | "test";
+    scope: string | null;
+    summary: string;
+    details: {
+        text: string;
+        changelog_category?: "Added" | "Breaking Changes" | "Changed" | "Deprecated" | "Fixed" | "Removed" | "Security" | undefined;
+        user_visible?: boolean | undefined;
+    }[];
+    issue_refs: string[];
+}, {}>;
 export declare function createProposeCommitTool(cwd: string, state: CommitAgentState): CustomTool<typeof proposeCommitSchema>;
 export {};

package/dist/types/commit/agentic/tools/recent-commits.d.ts

@@ -1,7 +1,6 @@
-import { z } from "zod/v4";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
-declare const recentCommitsSchema: z.ZodObject<{
-    count: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
+declare const recentCommitsSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    count?: number | undefined;
+}, {}>;
 export declare function createRecentCommitsTool(cwd: string): CustomTool<typeof recentCommitsSchema>;
 export {};

package/dist/types/commit/agentic/tools/schemas.d.ts

@@ -1,27 +1,6 @@
-import { z } from "zod/v4";
-export declare const commitTypeSchema: z.ZodEnum<{
-    build: "build";
-    chore: "chore";
-    ci: "ci";
-    docs: "docs";
-    feat: "feat";
-    fix: "fix";
-    perf: "perf";
-    refactor: "refactor";
-    revert: "revert";
-    style: "style";
-    test: "test";
-}>;
-export declare const detailSchema: z.ZodObject<{
-    text: z.ZodString;
-    changelog_category: z.ZodOptional<z.ZodEnum<{
-        Added: "Added";
-        "Breaking Changes": "Breaking Changes";
-        Changed: "Changed";
-        Deprecated: "Deprecated";
-        Fixed: "Fixed";
-        Removed: "Removed";
-        Security: "Security";
-    }>>;
-    user_visible: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
+export declare const commitTypeSchema: import("arktype/internal/variants/string.ts").StringType<"build" | "chore" | "ci" | "docs" | "feat" | "fix" | "perf" | "refactor" | "revert" | "style" | "test", {}>;
+export declare const detailSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    text: string;
+    changelog_category?: "Added" | "Breaking Changes" | "Changed" | "Deprecated" | "Fixed" | "Removed" | "Security" | undefined;
+    user_visible?: boolean | undefined;
+}, {}>;

package/dist/types/commit/agentic/tools/split-commit.d.ts

@@ -1,53 +1,32 @@
-import { z } from "zod/v4";
 import type { CommitAgentState } from "../../../commit/agentic/state";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
-declare const splitCommitSchema: z.ZodObject<{
-    commits: z.ZodArray<z.ZodObject<{
-        changes: z.ZodArray<z.ZodObject<{
-            path: z.ZodString;
-            hunks: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                type: z.ZodLiteral<"all">;
-            }, z.core.$strip>, z.ZodObject<{
-                type: z.ZodLiteral<"indices">;
-                indices: z.ZodArray<z.ZodNumber>;
-            }, z.core.$strip>, z.ZodObject<{
-                type: z.ZodLiteral<"lines">;
-                start: z.ZodNumber;
-                end: z.ZodNumber;
-            }, z.core.$strip>], "type">;
-        }, z.core.$strip>>;
-        type: z.ZodEnum<{
-            build: "build";
-            chore: "chore";
-            ci: "ci";
-            docs: "docs";
-            feat: "feat";
-            fix: "fix";
-            perf: "perf";
-            refactor: "refactor";
-            revert: "revert";
-            style: "style";
-            test: "test";
-        }>;
-        scope: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
-        summary: z.ZodString;
-        details: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            text: z.ZodString;
-            changelog_category: z.ZodOptional<z.ZodEnum<{
-                Added: "Added";
-                "Breaking Changes": "Breaking Changes";
-                Changed: "Changed";
-                Deprecated: "Deprecated";
-                Fixed: "Fixed";
-                Removed: "Removed";
-                Security: "Security";
-            }>>;
-            user_visible: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>>>;
-        issue_refs: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        rationale: z.ZodOptional<z.ZodString>;
-        dependencies: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+declare const splitCommitSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    commits: {
+        changes: {
+            path: string;
+            hunks: {
+                type: "all";
+            } | {
+                type: "indices";
+                indices: number[];
+            } | {
+                type: "lines";
+                start: number;
+                end: number;
+            };
+        }[];
+        type: "build" | "chore" | "ci" | "docs" | "feat" | "fix" | "perf" | "refactor" | "revert" | "style" | "test";
+        scope: string | null;
+        summary: string;
+        details?: {
+            text: string;
+            changelog_category?: "Added" | "Breaking Changes" | "Changed" | "Deprecated" | "Fixed" | "Removed" | "Security" | undefined;
+            user_visible?: boolean | undefined;
+        }[] | undefined;
+        issue_refs?: string[] | undefined;
+        rationale?: string | undefined;
+        dependencies?: number[] | undefined;
+    }[];
+}, {}>;
 export declare function createSplitCommitTool(cwd: string, state: CommitAgentState, changelogTargets: string[]): CustomTool<typeof splitCommitSchema>;
 export {};