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

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" });

package/src/config/model-registry.ts

@@ -30,7 +30,6 @@ const DEFAULT_LOCAL_TOKEN = "lm-studio-local";
 import { registerOAuthProvider, unregisterOAuthProviders } from "@oh-my-pi/pi-ai/utils/oauth";
 import type { OAuthCredentials, OAuthLoginCallbacks } from "@oh-my-pi/pi-ai/utils/oauth/types";
 import { isRecord, logger } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
 import { parseModelString, resolveProviderModelReference } from "../config/model-resolver";
 import { isValidThemeColor, type ThemeColor } from "../modes/theme/theme";
 import type { AuthStorage, OAuthCredential } from "../session/auth-storage";
@@ -43,6 +42,13 @@ import {
 	formatCanonicalVariantSelector,
 	type ModelEquivalenceConfig,
 } from "./model-equivalence";
+import {
+	type ModelOverride,
+	type ModelsConfig,
+	ModelsConfigSchema,
+	type ProviderAuthMode,
+	type ProviderDiscovery,
+} from "./models-config-schema";
 import { type Settings, settings } from "./settings";
 
 export type { CanonicalModelIndex, CanonicalModelRecord, CanonicalModelVariant, ModelEquivalenceConfig };
@@ -121,194 +127,6 @@ export function getRoleInfo(role: string, settings: Settings): RoleInfo {
 	return { name: role, color: "muted" };
 }
 
-const OpenRouterRoutingSchema = Type.Object({
-	only: Type.Optional(Type.Array(Type.String())),
-	order: Type.Optional(Type.Array(Type.String())),
-});
-
-// Schema for Vercel AI Gateway routing preferences
-const VercelGatewayRoutingSchema = Type.Object({
-	only: Type.Optional(Type.Array(Type.String())),
-	order: Type.Optional(Type.Array(Type.String())),
-});
-
-// Schema for OpenAI compatibility settings
-const ReasoningEffortMapSchema = Type.Object({
-	minimal: Type.Optional(Type.String()),
-	low: Type.Optional(Type.String()),
-	medium: Type.Optional(Type.String()),
-	high: Type.Optional(Type.String()),
-	xhigh: Type.Optional(Type.String()),
-});
-
-const OpenAICompatSchema = Type.Object({
-	supportsStore: Type.Optional(Type.Boolean()),
-	supportsDeveloperRole: Type.Optional(Type.Boolean()),
-	supportsReasoningEffort: Type.Optional(Type.Boolean()),
-	reasoningEffortMap: Type.Optional(ReasoningEffortMapSchema),
-	maxTokensField: Type.Optional(Type.Union([Type.Literal("max_completion_tokens"), Type.Literal("max_tokens")])),
-	supportsUsageInStreaming: Type.Optional(Type.Boolean()),
-	requiresToolResultName: Type.Optional(Type.Boolean()),
-	requiresMistralToolIds: Type.Optional(Type.Boolean()),
-	requiresAssistantAfterToolResult: Type.Optional(Type.Boolean()),
-	requiresThinkingAsText: Type.Optional(Type.Boolean()),
-	reasoningContentField: Type.Optional(
-		Type.Union([Type.Literal("reasoning_content"), Type.Literal("reasoning"), Type.Literal("reasoning_text")]),
-	),
-	requiresReasoningContentForToolCalls: Type.Optional(Type.Boolean()),
-	requiresAssistantContentForToolCalls: Type.Optional(Type.Boolean()),
-	supportsToolChoice: Type.Optional(Type.Boolean()),
-	disableReasoningOnForcedToolChoice: Type.Optional(Type.Boolean()),
-	thinkingFormat: Type.Optional(
-		Type.Union([
-			Type.Literal("openai"),
-			Type.Literal("openrouter"),
-			Type.Literal("zai"),
-			Type.Literal("qwen"),
-			Type.Literal("qwen-chat-template"),
-		]),
-	),
-	openRouterRouting: Type.Optional(OpenRouterRoutingSchema),
-	vercelGatewayRouting: Type.Optional(VercelGatewayRoutingSchema),
-	extraBody: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
-	supportsStrictMode: Type.Optional(Type.Boolean()),
-	toolStrictMode: Type.Optional(Type.Union([Type.Literal("all_strict"), Type.Literal("none")])),
-});
-
-const EffortSchema = Type.Union([
-	Type.Literal("minimal"),
-	Type.Literal("low"),
-	Type.Literal("medium"),
-	Type.Literal("high"),
-	Type.Literal("xhigh"),
-]);
-
-const ThinkingControlModeSchema = Type.Union([
-	Type.Literal("effort"),
-	Type.Literal("budget"),
-	Type.Literal("google-level"),
-	Type.Literal("anthropic-adaptive"),
-	Type.Literal("anthropic-budget-effort"),
-]);
-
-const ModelThinkingSchema = Type.Object({
-	minLevel: EffortSchema,
-	maxLevel: EffortSchema,
-	mode: ThinkingControlModeSchema,
-	defaultLevel: Type.Optional(EffortSchema),
-});
-
-// Schema for custom model definition
-// Most fields are optional with sensible defaults for local models (Ollama, LM Studio, etc.)
-const ModelDefinitionSchema = Type.Object({
-	id: Type.String({ minLength: 1 }),
-	name: Type.Optional(Type.String({ minLength: 1 })),
-	api: Type.Optional(
-		Type.Union([
-			Type.Literal("openai-completions"),
-			Type.Literal("openai-responses"),
-			Type.Literal("openai-codex-responses"),
-			Type.Literal("azure-openai-responses"),
-			Type.Literal("anthropic-messages"),
-			Type.Literal("google-generative-ai"),
-			Type.Literal("google-vertex"),
-		]),
-	),
-	baseUrl: Type.Optional(Type.String({ minLength: 1 })),
-	reasoning: Type.Optional(Type.Boolean()),
-	thinking: Type.Optional(ModelThinkingSchema),
-	input: Type.Optional(Type.Array(Type.Union([Type.Literal("text"), Type.Literal("image")]))),
-	cost: Type.Optional(
-		Type.Object({
-			input: Type.Number(),
-			output: Type.Number(),
-			cacheRead: Type.Number(),
-			cacheWrite: Type.Number(),
-		}),
-	),
-	premiumMultiplier: Type.Optional(Type.Number()),
-	contextWindow: Type.Optional(Type.Number()),
-	maxTokens: Type.Optional(Type.Number()),
-	headers: Type.Optional(Type.Record(Type.String(), Type.String())),
-	compat: Type.Optional(OpenAICompatSchema),
-	contextPromotionTarget: Type.Optional(Type.String({ minLength: 1 })),
-});
-
-// Schema for per-model overrides (all fields optional, merged with built-in model)
-const ModelOverrideSchema = Type.Object({
-	name: Type.Optional(Type.String({ minLength: 1 })),
-	reasoning: Type.Optional(Type.Boolean()),
-	thinking: Type.Optional(ModelThinkingSchema),
-	input: Type.Optional(Type.Array(Type.Union([Type.Literal("text"), Type.Literal("image")]))),
-	cost: Type.Optional(
-		Type.Object({
-			input: Type.Optional(Type.Number()),
-			output: Type.Optional(Type.Number()),
-			cacheRead: Type.Optional(Type.Number()),
-			cacheWrite: Type.Optional(Type.Number()),
-		}),
-	),
-	premiumMultiplier: Type.Optional(Type.Number()),
-	contextWindow: Type.Optional(Type.Number()),
-	maxTokens: Type.Optional(Type.Number()),
-	headers: Type.Optional(Type.Record(Type.String(), Type.String())),
-	compat: Type.Optional(OpenAICompatSchema),
-	contextPromotionTarget: Type.Optional(Type.String({ minLength: 1 })),
-});
-
-type ModelOverride = Static<typeof ModelOverrideSchema>;
-
-const ProviderDiscoverySchema = Type.Object({
-	type: Type.Union([
-		Type.Literal("ollama"),
-		Type.Literal("llama.cpp"),
-		Type.Literal("lm-studio"),
-		Type.Literal("openai-models-list"),
-	]),
-});
-
-const ProviderAuthSchema = Type.Union([Type.Literal("apiKey"), Type.Literal("none"), Type.Literal("oauth")]);
-
-const ProviderConfigSchema = Type.Object({
-	baseUrl: Type.Optional(Type.String({ minLength: 1 })),
-	apiKey: Type.Optional(Type.String({ minLength: 1 })),
-	api: Type.Optional(
-		Type.Union([
-			Type.Literal("openai-completions"),
-			Type.Literal("openai-responses"),
-			Type.Literal("openai-codex-responses"),
-			Type.Literal("azure-openai-responses"),
-			Type.Literal("anthropic-messages"),
-			Type.Literal("google-generative-ai"),
-			Type.Literal("google-vertex"),
-		]),
-	),
-	headers: Type.Optional(Type.Record(Type.String(), Type.String())),
-	compat: Type.Optional(OpenAICompatSchema),
-	authHeader: Type.Optional(Type.Boolean()),
-	auth: Type.Optional(ProviderAuthSchema),
-	discovery: Type.Optional(ProviderDiscoverySchema),
-	models: Type.Optional(Type.Array(ModelDefinitionSchema)),
-	modelOverrides: Type.Optional(Type.Record(Type.String(), ModelOverrideSchema)),
-	/** When true, disables strict tool schemas for this provider (for third-party Anthropic-compatible endpoints that reject the strict field). */
-	disableStrictTools: Type.Optional(Type.Boolean()),
-});
-
-const EquivalenceConfigSchema = Type.Object({
-	overrides: Type.Optional(Type.Record(Type.String(), Type.String({ minLength: 1 }))),
-	exclude: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
-});
-
-const ModelsConfigSchema = Type.Object({
-	providers: Type.Optional(Type.Record(Type.String(), ProviderConfigSchema)),
-	equivalence: Type.Optional(EquivalenceConfigSchema),
-});
-
-type ModelsConfig = Static<typeof ModelsConfigSchema>;
-
-type ProviderAuthMode = Static<typeof ProviderAuthSchema>;
-type ProviderDiscovery = Static<typeof ProviderDiscoverySchema>;
-
 type ProviderValidationMode = "models-config" | "runtime-register";
 
 interface ProviderValidationModel {
@@ -347,12 +165,13 @@ function validateProviderConfiguration(
 				!config.baseUrl &&
 				!config.headers &&
 				!config.compat &&
+				!config.apiKey &&
 				!config.disableStrictTools &&
 				!hasModelOverrides &&
 				!config.discovery
 			) {
 				throw new Error(
-					`Provider ${providerName}: must specify "baseUrl", "headers", "compat", "disableStrictTools", "modelOverrides", "discovery", or "models"`,
+					`Provider ${providerName}: must specify "baseUrl", "headers", "apiKey", "compat", "disableStrictTools", "modelOverrides", "discovery", or "models"`,
 				);
 			}
 		}
@@ -1015,8 +834,12 @@ export class ModelRegistry {
 
 		this.#addImplicitDiscoverableProviders(configuredProviders);
 		const builtInModels = this.#applyHardcodedModelPolicies(this.#loadBuiltInModels(overrides));
+		const cachedStandardModels = this.#applyHardcodedModelPolicies(this.#loadCachedStandardProviderModels());
 		const cachedDiscoveries = this.#applyHardcodedModelPolicies(this.#loadCachedDiscoverableModels());
-		const resolvedDefaults = this.#mergeResolvedModels(builtInModels, cachedDiscoveries);
+		const resolvedDefaults = this.#mergeResolvedModels(
+			this.#mergeResolvedModels(builtInModels, cachedStandardModels),
+			cachedDiscoveries,
+		);
 		const withConfigModels = this.#mergeCustomModels(resolvedDefaults, this.#customModelOverlays);
 		// Merge runtime extension models so they survive refresh() cycles
 		const combined = this.#mergeCustomModels(withConfigModels, this.#runtimeModelOverlays);
@@ -1115,6 +938,32 @@ export class ModelRegistry {
 		return merged;
 	}
 
+	#loadCachedStandardProviderModels(): Model<Api>[] {
+		const configuredDiscoveryProviders = new Set(this.#discoverableProviders.map(provider => provider.provider));
+		const cachedModels: Model<Api>[] = [];
+		for (const descriptor of PROVIDER_DESCRIPTORS) {
+			if (configuredDiscoveryProviders.has(descriptor.providerId)) {
+				continue;
+			}
+			const cache = readModelCache<Api>(descriptor.providerId, 24 * 60 * 60 * 1000, Date.now, this.#cacheDbPath);
+			if (!cache) {
+				continue;
+			}
+			const models = cache.models.map(model =>
+				model.provider === descriptor.providerId ? model : { ...model, provider: descriptor.providerId },
+			);
+			const providerOverride = this.#providerOverrides.get(descriptor.providerId);
+			const withTransport = providerOverride
+				? models.map(model => this.#applyProviderTransportOverride(model, providerOverride))
+				: models;
+			const withCompat = providerOverride?.compat
+				? withTransport.map(model => ({ ...model, compat: mergeCompat(model.compat, providerOverride.compat) }))
+				: withTransport;
+			cachedModels.push(...this.#applyProviderModelOverrides(descriptor.providerId, withCompat));
+		}
+		return cachedModels;
+	}
+
 	#loadCachedDiscoverableModels(): Model<Api>[] {
 		const cachedModels: Model<Api>[] = [];
 		for (const providerConfig of this.#discoverableProviders) {

package/src/config/models-config-schema.ts

@@ -0,0 +1,166 @@
+import * as z from "zod/v4";
+
+const OpenRouterRoutingSchema = z.object({
+	only: z.array(z.string()).optional(),
+	order: z.array(z.string()).optional(),
+});
+
+const VercelGatewayRoutingSchema = z.object({
+	only: z.array(z.string()).optional(),
+	order: z.array(z.string()).optional(),
+});
+
+const ReasoningEffortMapSchema = z.object({
+	minimal: z.string().optional(),
+	low: z.string().optional(),
+	medium: z.string().optional(),
+	high: z.string().optional(),
+	xhigh: z.string().optional(),
+});
+
+export const OpenAICompatSchema = z.object({
+	supportsStore: z.boolean().optional(),
+	supportsDeveloperRole: z.boolean().optional(),
+	supportsMultipleSystemMessages: z.boolean().optional(),
+	supportsReasoningEffort: z.boolean().optional(),
+	reasoningEffortMap: ReasoningEffortMapSchema.optional(),
+	maxTokensField: z.enum(["max_completion_tokens", "max_tokens"]).optional(),
+	supportsUsageInStreaming: z.boolean().optional(),
+	requiresToolResultName: z.boolean().optional(),
+	requiresMistralToolIds: z.boolean().optional(),
+	requiresAssistantAfterToolResult: z.boolean().optional(),
+	requiresThinkingAsText: z.boolean().optional(),
+	reasoningContentField: z.enum(["reasoning_content", "reasoning", "reasoning_text"]).optional(),
+	requiresReasoningContentForToolCalls: z.boolean().optional(),
+	allowsSyntheticReasoningContentForToolCalls: z.boolean().optional(),
+	requiresAssistantContentForToolCalls: z.boolean().optional(),
+	supportsToolChoice: z.boolean().optional(),
+	disableReasoningOnForcedToolChoice: z.boolean().optional(),
+	disableReasoningOnToolChoice: z.boolean().optional(),
+	thinkingFormat: z.enum(["openai", "openrouter", "zai", "qwen", "qwen-chat-template"]).optional(),
+	openRouterRouting: OpenRouterRoutingSchema.optional(),
+	vercelGatewayRouting: VercelGatewayRoutingSchema.optional(),
+	extraBody: z.record(z.string(), z.unknown()).optional(),
+	supportsStrictMode: z.boolean().optional(),
+	toolStrictMode: z.enum(["all_strict", "none"]).optional(),
+});
+
+const EffortSchema = z.enum(["minimal", "low", "medium", "high", "xhigh"]);
+
+const ThinkingControlModeSchema = z.enum([
+	"effort",
+	"budget",
+	"google-level",
+	"anthropic-adaptive",
+	"anthropic-budget-effort",
+]);
+
+const ModelThinkingSchema = z.object({
+	minLevel: EffortSchema,
+	maxLevel: EffortSchema,
+	mode: ThinkingControlModeSchema,
+	defaultLevel: EffortSchema.optional(),
+	levels: z.array(EffortSchema).optional(),
+});
+
+const ModelDefinitionSchema = z.object({
+	id: z.string().min(1),
+	name: z.string().min(1).optional(),
+	api: z
+		.enum([
+			"openai-completions",
+			"openai-responses",
+			"openai-codex-responses",
+			"azure-openai-responses",
+			"anthropic-messages",
+			"google-generative-ai",
+			"google-vertex",
+		])
+		.optional(),
+	baseUrl: z.string().min(1).optional(),
+	reasoning: z.boolean().optional(),
+	thinking: ModelThinkingSchema.optional(),
+	input: z.array(z.enum(["text", "image"])).optional(),
+	cost: z
+		.object({
+			input: z.number(),
+			output: z.number(),
+			cacheRead: z.number(),
+			cacheWrite: z.number(),
+		})
+		.optional(),
+	premiumMultiplier: z.number().optional(),
+	contextWindow: z.number().optional(),
+	maxTokens: z.number().optional(),
+	headers: z.record(z.string(), z.string()).optional(),
+	compat: OpenAICompatSchema.optional(),
+	contextPromotionTarget: z.string().min(1).optional(),
+});
+
+export const ModelOverrideSchema = z.object({
+	name: z.string().min(1).optional(),
+	reasoning: z.boolean().optional(),
+	thinking: ModelThinkingSchema.optional(),
+	input: z.array(z.enum(["text", "image"])).optional(),
+	cost: z
+		.object({
+			input: z.number().optional(),
+			output: z.number().optional(),
+			cacheRead: z.number().optional(),
+			cacheWrite: z.number().optional(),
+		})
+		.optional(),
+	premiumMultiplier: z.number().optional(),
+	contextWindow: z.number().optional(),
+	maxTokens: z.number().optional(),
+	headers: z.record(z.string(), z.string()).optional(),
+	compat: OpenAICompatSchema.optional(),
+	contextPromotionTarget: z.string().min(1).optional(),
+});
+
+export type ModelOverride = z.infer<typeof ModelOverrideSchema>;
+
+export const ProviderDiscoverySchema = z.object({
+	type: z.enum(["ollama", "llama.cpp", "lm-studio", "openai-models-list"]),
+});
+
+export const ProviderAuthSchema = z.enum(["apiKey", "none", "oauth"]);
+
+export type ProviderAuthMode = z.infer<typeof ProviderAuthSchema>;
+export type ProviderDiscovery = z.infer<typeof ProviderDiscoverySchema>;
+
+const ProviderConfigSchema = z.object({
+	baseUrl: z.string().min(1).optional(),
+	apiKey: z.string().min(1).optional(),
+	api: z
+		.enum([
+			"openai-completions",
+			"openai-responses",
+			"openai-codex-responses",
+			"azure-openai-responses",
+			"anthropic-messages",
+			"google-generative-ai",
+			"google-vertex",
+		])
+		.optional(),
+	headers: z.record(z.string(), z.string()).optional(),
+	compat: OpenAICompatSchema.optional(),
+	authHeader: z.boolean().optional(),
+	auth: ProviderAuthSchema.optional(),
+	discovery: ProviderDiscoverySchema.optional(),
+	models: z.array(ModelDefinitionSchema).optional(),
+	modelOverrides: z.record(z.string(), ModelOverrideSchema).optional(),
+	disableStrictTools: z.boolean().optional(),
+});
+
+const EquivalenceConfigSchema = z.object({
+	overrides: z.record(z.string(), z.string().min(1)).optional(),
+	exclude: z.array(z.string().min(1)).optional(),
+});
+
+export const ModelsConfigSchema = z.object({
+	providers: z.record(z.string(), ProviderConfigSchema).optional(),
+	equivalence: EquivalenceConfigSchema.optional(),
+});
+
+export type ModelsConfig = z.infer<typeof ModelsConfigSchema>;

package/src/config/settings-schema.ts

@@ -1648,6 +1648,17 @@ export const SETTINGS_SCHEMA = {
 	},
 	"bashInterceptor.patterns": { type: "array", default: DEFAULT_BASH_INTERCEPTOR_RULES },
 
+	"bash.stripTrailingHeadTail": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "editing",
+			label: "Strip Trailing head/tail",
+			description:
+				"Silently drop trailing `| head`/`| tail` pipes from single-line bash commands. Output is already truncated automatically.",
+		},
+	},
+
 	// Shell output minimizer
 	"shellMinimizer.enabled": {
 		type: "boolean",
@@ -2318,6 +2329,24 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"task.maxRuntimeMs": {
+		type: "number",
+		default: 0,
+		ui: {
+			tab: "tasks",
+			label: "Max Subagent Runtime",
+			description:
+				"Hard wall-clock limit per subagent (ms). 0 disables it. Defense-in-depth against provider-side stream hangs that escape the inference-layer watchdog; triggers a normal subagent abort with a 'timed out' reason.",
+			options: [
+				{ value: "0", label: "Unlimited", description: "Default" },
+				{ value: "300000", label: "5 minutes" },
+				{ value: "900000", label: "15 minutes" },
+				{ value: "1800000", label: "30 minutes" },
+				{ value: "3600000", label: "1 hour" },
+			],
+		},
+	},
+
 	"task.disabledAgents": {
 		type: "array",
 		default: [] as string[],

package/src/discovery/claude-plugins.ts

@@ -31,6 +31,7 @@ const PRIORITY = 70; // Below claude.ts (80) so user .claude/ overrides win
 interface ClaudePluginManifest {
 	skills?: string;
 	"slash-commands"?: string;
+	commands?: string;
 }
 
 interface ResolvedPluginDir {
@@ -59,24 +60,35 @@ function isWithinPluginRoot(rootPath: string, targetPath: string): boolean {
 
 async function resolvePluginDir(
 	root: ClaudePluginRoot,
-	manifestKey: keyof ClaudePluginManifest,
+	manifestKeys: ReadonlyArray<keyof ClaudePluginManifest>,
 	fallback: string,
 ): Promise<ResolvedPluginDir> {
 	const manifest = await readPluginManifest(root);
 	const fallbackDir = path.join(root.path, fallback);
-	const configured = manifest?.[manifestKey];
-	if (typeof configured !== "string" || !configured.trim()) {
+
+	let configured: string | undefined;
+	let matchedKey: keyof ClaudePluginManifest | undefined;
+	for (const key of manifestKeys) {
+		const val = manifest?.[key];
+		if (typeof val === "string" && val.trim()) {
+			configured = val.trim();
+			matchedKey = key;
+			break;
+		}
+	}
+
+	if (configured === undefined) {
 		return { dir: fallbackDir };
 	}
 
-	const resolved = path.resolve(root.path, configured.trim());
+	const resolved = path.resolve(root.path, configured);
 	if (isWithinPluginRoot(root.path, resolved)) {
 		return { dir: resolved };
 	}
 
 	return {
 		dir: fallbackDir,
-		warning: `[claude-plugins] Ignoring ${String(manifestKey)} path outside plugin root for ${root.id}: ${configured}`,
+		warning: `[claude-plugins] Ignoring ${String(matchedKey)} path outside plugin root for ${root.id}: ${configured}`,
 	};
 }
 
@@ -93,7 +105,7 @@ async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
 
 	const results = await Promise.all(
 		roots.map(async root => {
-			const { dir: skillsDir, warning } = await resolvePluginDir(root, "skills", "skills");
+			const { dir: skillsDir, warning } = await resolvePluginDir(root, ["skills"], "skills");
 			const result = await scanSkillsFromDir(ctx, {
 				dir: skillsDir,
 				providerId: PROVIDER_ID,
@@ -128,7 +140,7 @@ async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashComm
 
 	const results = await Promise.all(
 		roots.map(async root => {
-			const { dir: commandsDir, warning } = await resolvePluginDir(root, "slash-commands", "commands");
+			const { dir: commandsDir, warning } = await resolvePluginDir(root, ["commands", "slash-commands"], "commands");
 			const result = await loadFilesFromDir<SlashCommand>(ctx, commandsDir, PROVIDER_ID, root.scope, {
 				extensions: ["md"],
 				transform: (name, content, filePath, source) => {

package/src/edit/index.ts

@@ -1,6 +1,6 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { prompt } from "@oh-my-pi/pi-utils";
-import type { Static } from "@sinclair/typebox";
+import type * as z from "zod/v4";
 import {
 	executeHashlineSingle,
 	HashlineMismatchError,
@@ -53,7 +53,7 @@ type TInput =
 	| typeof vimSchema
 	| typeof applyPatchSchema;
 
-type VimParams = Static<typeof vimSchema>;
+type VimParams = z.infer<typeof vimSchema>;
 type EditParams = ReplaceParams | PatchParams | HashlineParams | VimParams | ApplyPatchParams;
 type EditToolResultDetails = EditToolDetails | VimToolDetails;