@oh-my-pi/pi-coding-agent 15.0.2 → 15.1.0

package/src/autoresearch/tools/update-notes.ts

@@ -1,5 +1,5 @@
 import { Text } from "@oh-my-pi/pi-tui";
-import { Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import type { ToolDefinition } from "../../extensibility/extensions";
 import type { Theme } from "../../modes/theme/theme";
 import { replaceTabs, truncateToWidth } from "../../tools/render-utils";
@@ -8,16 +8,16 @@ import { buildExperimentState } from "../state";
 import { openAutoresearchStorageIfExists } from "../storage";
 import type { AutoresearchToolFactoryOptions } from "../types";
 
-const updateNotesSchema = Type.Object({
-	body: Type.String({
-		description: "Replacement markdown body for the active autoresearch session's notes (your durable playbook).",
-	}),
-	append_idea: Type.Optional(
-		Type.String({
-			description:
-				"When set, append this string as a new bullet under an Ideas section instead of replacing the body. `body` is ignored.",
-		}),
-	),
+const updateNotesSchema = z.object({
+	body: z
+		.string()
+		.describe("Replacement markdown body for the active autoresearch session's notes (your durable playbook)."),
+	append_idea: z
+		.string()
+		.describe(
+			"When set, append this string as a new bullet under an Ideas section instead of replacing the body. `body` is ignored.",
+		)
+		.optional(),
 });
 
 interface UpdateNotesDetails {

package/src/commit/agentic/tools/analyze-file.ts

@@ -1,5 +1,5 @@
 import { prompt } from "@oh-my-pi/pi-utils";
-import { Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import analyzeFilePrompt from "../../../commit/agentic/prompts/analyze-file.md" with { type: "text" };
 import type { CommitAgentState } from "../../../commit/agentic/state";
 import type { NumstatEntry } from "../../../commit/types";
@@ -12,9 +12,9 @@ import type { TaskParams } from "../../../task/types";
 import type { ToolSession } from "../../../tools";
 import { getFilePriority } from "./git-file-diff";
 
-const analyzeFileSchema = Type.Object({
-	files: Type.Array(Type.String({ description: "File path" }), { minItems: 1 }),
-	goal: Type.Optional(Type.String({ description: "Optional analysis focus" })),
+const analyzeFileSchema = z.object({
+	files: z.array(z.string().describe("File path")).min(1),
+	goal: z.string().describe("Optional analysis focus").optional(),
 });
 
 const analyzeFileOutputSchema = {

package/src/commit/agentic/tools/git-file-diff.ts

@@ -1,4 +1,4 @@
-import { Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import type { CommitAgentState } from "../../../commit/agentic/state";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
 import * as git from "../../../utils/git";
@@ -131,9 +131,9 @@ function processDiffs(files: string[], diffs: Map<string, string>): { result: st
 	return { result: parts.join("\n\n"), truncatedFiles };
 }
 
-const gitFileDiffSchema = Type.Object({
-	files: Type.Array(Type.String({ description: "Files to diff" }), { minItems: 1, maxItems: 10 }),
-	staged: Type.Optional(Type.Boolean({ description: "Use staged changes (default: true)" })),
+const gitFileDiffSchema = z.object({
+	files: z.array(z.string().describe("Files to diff")).min(1).max(10),
+	staged: z.boolean().describe("Use staged changes (default: true)").optional(),
 });
 
 export function createGitFileDiffTool(cwd: string, state: CommitAgentState): CustomTool<typeof gitFileDiffSchema> {

package/src/commit/agentic/tools/git-hunk.ts

@@ -1,12 +1,12 @@
-import { Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import type { DiffHunk, FileHunks } from "../../../commit/types";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
 import * as git from "../../../utils/git";
 
-const gitHunkSchema = Type.Object({
-	file: Type.String({ description: "File path" }),
-	hunks: Type.Optional(Type.Array(Type.Number({ description: "1-based hunk indices" }), { minItems: 1 })),
-	staged: Type.Optional(Type.Boolean({ description: "Use staged changes (default: true)" })),
+const gitHunkSchema = z.object({
+	file: z.string().describe("File path"),
+	hunks: z.array(z.number().describe("1-based hunk indices")).min(1).optional(),
+	staged: z.boolean().describe("Use staged changes (default: true)").optional(),
 });
 
 function selectHunks(fileHunks: FileHunks, requested?: number[]): DiffHunk[] {

package/src/commit/agentic/tools/git-overview.ts

@@ -1,4 +1,4 @@
-import { Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import type { CommitAgentState, GitOverviewSnapshot } from "../../../commit/agentic/state";
 import { extractScopeCandidates } from "../../../commit/analysis/scope";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
@@ -42,9 +42,9 @@ function filterExcludedFiles(files: string[]): { filtered: string[]; excluded: s
 	return { filtered, excluded };
 }
 
-const gitOverviewSchema = Type.Object({
-	staged: Type.Optional(Type.Boolean({ description: "Use staged changes (default: true)" })),
-	include_untracked: Type.Optional(Type.Boolean({ description: "Include untracked files when staged=false" })),
+const gitOverviewSchema = z.object({
+	staged: z.boolean().describe("Use staged changes (default: true)").optional(),
+	include_untracked: z.boolean().describe("Include untracked files when staged=false").optional(),
 });
 
 export function createGitOverviewTool(cwd: string, state: CommitAgentState): CustomTool<typeof gitOverviewSchema> {

package/src/commit/agentic/tools/propose-changelog.ts

@@ -1,29 +1,29 @@
-import { type TSchema, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import type { CommitAgentState } from "../../../commit/agentic/state";
 import { CHANGELOG_CATEGORIES, type ChangelogCategory } from "../../../commit/types";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
 
-const changelogEntryProperties = CHANGELOG_CATEGORIES.reduce<Record<ChangelogCategory, TSchema>>(
+const changelogEntryProperties = CHANGELOG_CATEGORIES.reduce<Record<ChangelogCategory, z.ZodType>>(
 	(acc, category) => {
-		acc[category] = Type.Optional(Type.Array(Type.String()));
+		acc[category] = z.array(z.string()).optional();
 		return acc;
 	},
-	{} as Record<ChangelogCategory, TSchema>,
+	{} as Record<ChangelogCategory, z.ZodType>,
 );
 
-const changelogEntriesSchema = Type.Object(changelogEntryProperties);
-const changelogDeletionsSchema = Type.Object(changelogEntryProperties, {
-	description: "Entries to remove from existing changelog sections (case-insensitive match)",
-});
+const changelogEntriesSchema = z.object(changelogEntryProperties);
+const changelogDeletionsSchema = z
+	.object(changelogEntryProperties)
+	.describe("Entries to remove from existing changelog sections (case-insensitive match)");
 
-const changelogEntrySchema = Type.Object({
-	path: Type.String(),
+const changelogEntrySchema = z.object({
+	path: z.string(),
 	entries: changelogEntriesSchema,
-	deletions: Type.Optional(changelogDeletionsSchema),
+	deletions: changelogDeletionsSchema.optional(),
 });
 
-const proposeChangelogSchema = Type.Object({
-	entries: Type.Array(changelogEntrySchema),
+const proposeChangelogSchema = z.object({
+	entries: z.array(changelogEntrySchema),
 });
 
 interface ChangelogResponse {

package/src/commit/agentic/tools/propose-commit.ts

@@ -1,4 +1,4 @@
-import { Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import type { CommitAgentState } from "../../../commit/agentic/state";
 import {
 	capDetails,
@@ -15,12 +15,12 @@ import type { CustomTool } from "../../../extensibility/custom-tools/types";
 import * as git from "../../../utils/git";
 import { commitTypeSchema, detailSchema } from "./schemas.js";
 
-const proposeCommitSchema = Type.Object({
+const proposeCommitSchema = z.object({
 	type: commitTypeSchema,
-	scope: Type.Union([Type.String(), Type.Null()]),
-	summary: Type.String(),
-	details: Type.Array(detailSchema),
-	issue_refs: Type.Array(Type.String()),
+	scope: z.union([z.string(), z.null()]),
+	summary: z.string(),
+	details: z.array(detailSchema),
+	issue_refs: z.array(z.string()),
 });
 
 interface ProposalResponse {

package/src/commit/agentic/tools/recent-commits.ts

@@ -1,9 +1,9 @@
-import { Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
 import * as git from "../../../utils/git";
 
-const recentCommitsSchema = Type.Object({
-	count: Type.Optional(Type.Number({ description: "Number of commits to fetch", minimum: 1, maximum: 50 })),
+const recentCommitsSchema = z.object({
+	count: z.number().min(1).max(50).describe("Number of commits to fetch").optional(),
 });
 
 interface RecentCommitStats {

package/src/commit/agentic/tools/schemas.ts

@@ -1,31 +1,31 @@
-import { Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 
-export const commitTypeSchema = Type.Union([
-	Type.Literal("feat"),
-	Type.Literal("fix"),
-	Type.Literal("refactor"),
-	Type.Literal("perf"),
-	Type.Literal("docs"),
-	Type.Literal("test"),
-	Type.Literal("build"),
-	Type.Literal("ci"),
-	Type.Literal("chore"),
-	Type.Literal("style"),
-	Type.Literal("revert"),
-]);
+export const commitTypeSchema = z.enum([
+	"feat",
+	"fix",
+	"refactor",
+	"perf",
+	"docs",
+	"test",
+	"build",
+	"ci",
+	"chore",
+	"style",
+	"revert",
+] as const);
 
-export const detailSchema = Type.Object({
-	text: Type.String(),
-	changelog_category: Type.Optional(
-		Type.Union([
-			Type.Literal("Added"),
-			Type.Literal("Changed"),
-			Type.Literal("Fixed"),
-			Type.Literal("Deprecated"),
-			Type.Literal("Removed"),
-			Type.Literal("Security"),
-			Type.Literal("Breaking Changes"),
-		]),
-	),
-	user_visible: Type.Optional(Type.Boolean()),
+export const detailSchema = z.object({
+	text: z.string(),
+	changelog_category: z
+		.union([
+			z.literal("Added"),
+			z.literal("Changed"),
+			z.literal("Fixed"),
+			z.literal("Deprecated"),
+			z.literal("Removed"),
+			z.literal("Security"),
+			z.literal("Breaking Changes"),
+		])
+		.optional(),
+	user_visible: z.boolean().optional(),
 });

package/src/commit/agentic/tools/split-commit.ts

@@ -1,4 +1,4 @@
-import { Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import type { CommitAgentState, SplitCommitGroup, SplitCommitPlan } from "../../../commit/agentic/state";
 import { computeDependencyOrder } from "../../../commit/agentic/topo-sort";
 import {
@@ -15,31 +15,32 @@ import type { CustomTool } from "../../../extensibility/custom-tools/types";
 import * as git from "../../../utils/git";
 import { commitTypeSchema, detailSchema } from "./schemas.js";
 
-const hunkSelectorSchema = Type.Union([
-	Type.Object({ type: Type.Literal("all") }),
-	Type.Object({ type: Type.Literal("indices"), indices: Type.Array(Type.Number(), { minItems: 1 }) }),
-	Type.Object({ type: Type.Literal("lines"), start: Type.Number(), end: Type.Number() }),
+const hunkSelectorSchema = z.discriminatedUnion("type", [
+	z.object({ type: z.literal("all") }),
+	z.object({ type: z.literal("indices"), indices: z.array(z.number()).min(1) }),
+	z.object({ type: z.literal("lines"), start: z.number(), end: z.number() }),
 ]);
 
-const fileChangeSchema = Type.Object({
-	path: Type.String(),
+const fileChangeSchema = z.object({
+	path: z.string(),
 	hunks: hunkSelectorSchema,
 });
 
-const splitCommitSchema = Type.Object({
-	commits: Type.Array(
-		Type.Object({
-			changes: Type.Array(fileChangeSchema, { minItems: 1 }),
-			type: commitTypeSchema,
-			scope: Type.Union([Type.String(), Type.Null()]),
-			summary: Type.String(),
-			details: Type.Optional(Type.Array(detailSchema)),
-			issue_refs: Type.Optional(Type.Array(Type.String())),
-			rationale: Type.Optional(Type.String()),
-			dependencies: Type.Optional(Type.Array(Type.Number())),
-		}),
-		{ minItems: 2 },
-	),
+const splitCommitSchema = z.object({
+	commits: z
+		.array(
+			z.object({
+				changes: z.array(fileChangeSchema).min(1),
+				type: commitTypeSchema,
+				scope: z.union([z.string(), z.null()]),
+				summary: z.string(),
+				details: z.array(detailSchema).optional(),
+				issue_refs: z.array(z.string()).optional(),
+				rationale: z.string().optional(),
+				dependencies: z.array(z.number()).optional(),
+			}),
+		)
+		.min(2),
 });
 
 interface SplitCommitResponse {

package/src/commit/analysis/summary.ts

@@ -2,7 +2,7 @@ import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Api, AssistantMessage, Model } from "@oh-my-pi/pi-ai";
 import { completeSimple, validateToolCall } from "@oh-my-pi/pi-ai";
 import { prompt } from "@oh-my-pi/pi-utils";
-import { Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import summarySystemPrompt from "../../commit/prompts/summary-system.md" with { type: "text" };
 import summaryUserPrompt from "../../commit/prompts/summary-user.md" with { type: "text" };
 import type { CommitSummary } from "../../commit/types";
@@ -12,8 +12,8 @@ import { extractTextContent, extractToolCall } from "../utils";
 const SummaryTool = {
 	name: "create_commit_summary",
 	description: "Generate the summary line for a conventional commit message.",
-	parameters: Type.Object({
-		summary: Type.String(),
+	parameters: z.object({
+		summary: z.string(),
 	}),
 };
 
@@ -83,7 +83,7 @@ function renderSummaryPrompt({
 function parseSummaryFromResponse(message: AssistantMessage, commitType: string, scope: string | null): CommitSummary {
 	const toolCall = extractToolCall(message, "create_commit_summary");
 	if (toolCall) {
-		const parsed = validateToolCall([SummaryTool], toolCall) as { summary: string };
+		const parsed = validateToolCall([SummaryTool], toolCall) as z.infer<(typeof SummaryTool)["parameters"]>;
 		return { summary: stripTypePrefix(parsed.summary, commitType, scope) };
 	}
 	const text = extractTextContent(message);

package/src/commit/changelog/generate.ts

@@ -2,27 +2,23 @@ import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Api, AssistantMessage, Model } from "@oh-my-pi/pi-ai";
 import { completeSimple, validateToolCall } from "@oh-my-pi/pi-ai";
 import { prompt } from "@oh-my-pi/pi-utils";
-import { type TSchema, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import changelogSystemPrompt from "../../commit/prompts/changelog-system.md" with { type: "text" };
 import changelogUserPrompt from "../../commit/prompts/changelog-user.md" with { type: "text" };
 import { CHANGELOG_CATEGORIES, type ChangelogCategory, type ChangelogGenerationResult } from "../../commit/types";
 import { toReasoningEffort } from "../../thinking";
 import { extractTextContent, extractToolCall, parseJsonPayload } from "../utils";
 
-const changelogEntryProperties = CHANGELOG_CATEGORIES.reduce<Record<ChangelogCategory, TSchema>>(
-	(acc, category) => {
-		acc[category] = Type.Optional(Type.Array(Type.String()));
-		return acc;
-	},
-	{} as Record<ChangelogCategory, TSchema>,
-);
+const changelogEntryShape = Object.fromEntries(
+	CHANGELOG_CATEGORIES.map(c => [c, z.array(z.string()).optional()] as const),
+) as Record<ChangelogCategory, z.ZodOptional<z.ZodArray<z.ZodString>>>;
 
-const changelogEntriesSchema = Type.Object(changelogEntryProperties);
+const changelogEntriesSchema = z.object(changelogEntryShape);
 
 export const changelogTool = {
 	name: "create_changelog_entries",
 	description: "Generate changelog entries grouped by Keep a Changelog categories.",
-	parameters: Type.Object({
+	parameters: z.object({
 		entries: changelogEntriesSchema,
 	}),
 };
@@ -72,7 +68,7 @@ export async function generateChangelogEntries({
 function parseChangelogResponse(message: AssistantMessage): ChangelogGenerationResult {
 	const toolCall = extractToolCall(message, "create_changelog_entries");
 	if (toolCall) {
-		const parsed = validateToolCall([changelogTool], toolCall) as ChangelogGenerationResult;
+		const parsed = validateToolCall([changelogTool], toolCall) as z.infer<(typeof changelogTool)["parameters"]>;
 		return { entries: parsed.entries ?? {} };
 	}
 

package/src/commit/shared-llm.ts

@@ -1,48 +1,36 @@
 import type { AssistantMessage } from "@oh-my-pi/pi-ai";
 import { validateToolCall } from "@oh-my-pi/pi-ai";
-import { Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import type { ChangelogCategory, ConventionalAnalysis } from "./types";
 import { extractTextContent, extractToolCall, normalizeAnalysis, parseJsonPayload } from "./utils";
 
+const changelogCategoryLiteral = z.enum([
+	"Added",
+	"Changed",
+	"Fixed",
+	"Deprecated",
+	"Removed",
+	"Security",
+	"Breaking Changes",
+]);
+
 /**
- * Shared TypeBox schema for the `create_conventional_analysis` tool used by
+ * Shared Zod schema for the `create_conventional_analysis` tool used by
  * both the single-pass analysis call and the map-reduce reduce phase. Schemas
  * are identical across phases — only the surrounding tool `description`
  * differs to reflect the input the phase is summarizing.
  */
-export const conventionalAnalysisParameters = Type.Object({
-	type: Type.Union([
-		Type.Literal("feat"),
-		Type.Literal("fix"),
-		Type.Literal("refactor"),
-		Type.Literal("docs"),
-		Type.Literal("test"),
-		Type.Literal("chore"),
-		Type.Literal("style"),
-		Type.Literal("perf"),
-		Type.Literal("build"),
-		Type.Literal("ci"),
-		Type.Literal("revert"),
-	]),
-	scope: Type.Union([Type.String(), Type.Null()]),
-	details: Type.Array(
-		Type.Object({
-			text: Type.String(),
-			changelog_category: Type.Optional(
-				Type.Union([
-					Type.Literal("Added"),
-					Type.Literal("Changed"),
-					Type.Literal("Fixed"),
-					Type.Literal("Deprecated"),
-					Type.Literal("Removed"),
-					Type.Literal("Security"),
-					Type.Literal("Breaking Changes"),
-				]),
-			),
-			user_visible: Type.Optional(Type.Boolean()),
+export const conventionalAnalysisParameters = z.object({
+	type: z.enum(["feat", "fix", "refactor", "docs", "test", "chore", "style", "perf", "build", "ci", "revert"]),
+	scope: z.union([z.string(), z.null()]),
+	details: z.array(
+		z.object({
+			text: z.string(),
+			changelog_category: changelogCategoryLiteral.optional(),
+			user_visible: z.boolean().optional(),
 		}),
 	),
-	issue_refs: Type.Array(Type.String()),
+	issue_refs: z.array(z.string()),
 });
 
 export interface ConventionalAnalysisTool {
@@ -80,7 +68,7 @@ export function parseConventionalAnalysisResponse(
 ): ConventionalAnalysis {
 	const toolCall = extractToolCall(message, tool.name);
 	if (toolCall) {
-		const parsed = validateToolCall([tool], toolCall) as ParsedConventionalAnalysis;
+		const parsed = validateToolCall([tool], toolCall) as z.infer<typeof conventionalAnalysisParameters>;
 		return normalizeAnalysis(parsed);
 	}
 	const text = extractTextContent(message);

package/src/config/config-file.ts

@@ -1,10 +1,14 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { getAgentDir, isEnoent, logger } from "@oh-my-pi/pi-utils";
-import type { TSchema } from "@sinclair/typebox";
-import { Value } from "@sinclair/typebox/value";
-import type { ErrorObject } from "ajv";
 import { JSONC, YAML } from "bun";
+import type { ZodType } from "zod/v4";
+
+/** Minimal subset of the AJV ConfigSchemaError shape this module actually relies on. */
+interface ConfigSchemaError {
+	instancePath: string;
+	message: string | undefined;
+}
 
 function migrateJsonToYml(jsonPath: string, ymlPath: string) {
 	try {
@@ -25,7 +29,7 @@ function migrateJsonToYml(jsonPath: string, ymlPath: string) {
 
 export interface IConfigFile<T> {
 	readonly id: string;
-	readonly schema: TSchema;
+	readonly schema: ZodType<T>;
 	path?(): string;
 	load(): T | null;
 	invalidate?(): void;
@@ -35,7 +39,7 @@ export class ConfigError extends Error {
 	readonly #message: string;
 	constructor(
 		public readonly id: string,
-		public readonly schemaErrors: ErrorObject[] | null | undefined,
+		public readonly schemaErrors: ConfigSchemaError[] | null | undefined,
 		public readonly other?: { err: unknown; stage: string },
 	) {
 		let messages: string[] | undefined;
@@ -68,7 +72,6 @@ export class ConfigError extends Error {
 				break;
 			default:
 				message = `${title}\n${messages!.map(m => `  - ${m}`).join("\n")}`;
-				break;
 		}
 
 		super(message, { cause });
@@ -99,7 +102,7 @@ export class ConfigFile<T> implements IConfigFile<T> {
 
 	constructor(
 		readonly id: string,
-		readonly schema: TSchema,
+		readonly schema: ZodType<T>,
 		configPath: string = path.join(getAgentDir(), `${id}.yml`),
 	) {
 		this.#basePath = configPath;
@@ -146,7 +149,14 @@ export class ConfigFile<T> implements IConfigFile<T> {
 	}
 
 	createDefault(): T {
-		return Value.Default(this.schema, [], undefined) as T;
+		const parsed = this.schema.safeParse({});
+		if (parsed.success) return parsed.data;
+		const fallback = this.schema.safeParse(undefined);
+		if (fallback.success) return fallback.data;
+		throw new ConfigError(this.id, undefined, {
+			err: new Error("Schema produced no default value"),
+			stage: "createDefault",
+		});
 	}
 
 	#storeCache(result: LoadResult<T>): LoadResult<T> {
@@ -169,17 +179,29 @@ export class ConfigFile<T> implements IConfigFile<T> {
 				throw new Error(`Invalid config file path: ${this.#basePath}`);
 			}
 
-			if (!Value.Check(this.schema, parsed)) {
-				const schemaErrors: ErrorObject[] = [];
-				for (const err of Value.Errors(this.schema, parsed)) {
-					schemaErrors.push({ instancePath: err.path, message: err.message } as ErrorObject);
+			const checked = this.schema.safeParse(parsed);
+			if (!checked.success) {
+				const schemaErrors: ConfigSchemaError[] = [];
+				for (const issue of checked.error.issues) {
+					const instancePath = issue.path.length === 0 ? "" : `/${issue.path.map(String).join("/")}`;
+					schemaErrors.push({ instancePath, message: issue.message });
 					if (schemaErrors.length >= 50) break;
 				}
 				const error = new ConfigError(this.id, schemaErrors);
 				logger.warn("Failed to parse config file", { path: this.path(), error });
 				return this.#storeCache({ error, status: "error" });
 			}
-			return this.#storeCache({ value: parsed as T, status: "ok" });
+			const value = checked.data;
+			try {
+				this.#auxValidate?.(value);
+			} catch (error) {
+				const wrapped =
+					error instanceof ConfigError
+						? error
+						: new ConfigError(this.id, undefined, { err: error, stage: "AuxValidate" });
+				return this.#storeCache({ error: wrapped, status: "error" });
+			}
+			return this.#storeCache({ value, status: "ok" });
 		} catch (error) {
 			if (isEnoent(error)) {
 				return this.#storeCache({ status: "not-found" });