@oh-my-pi/pi-coding-agent 12.9.0 → 12.10.1

package/src/config/model-registry.ts

@@ -1,26 +1,50 @@
 import {
 	type Api,
 	type AssistantMessageEventStream,
+	anthropicModelManagerOptions,
 	type Context,
+	cerebrasModelManagerOptions,
+	createModelManager,
+	cursorModelManagerOptions,
+	getBundledModels,
+	getBundledProviders,
 	getGitHubCopilotBaseUrl,
-	getModels,
-	getProviders,
+	githubCopilotModelManagerOptions,
+	googleAntigravityModelManagerOptions,
+	googleGeminiCliModelManagerOptions,
+	googleModelManagerOptions,
+	groqModelManagerOptions,
+	kimiCodeModelManagerOptions,
 	type Model,
+	type ModelManagerOptions,
+	mistralModelManagerOptions,
 	normalizeDomain,
 	type OAuthCredentials,
 	type OAuthLoginCallbacks,
+	openaiCodexModelManagerOptions,
+	openaiModelManagerOptions,
+	opencodeModelManagerOptions,
+	openrouterModelManagerOptions,
 	registerCustomApi,
 	registerOAuthProvider,
 	type SimpleStreamOptions,
+	syntheticModelManagerOptions,
 	unregisterCustomApis,
 	unregisterOAuthProviders,
+	vercelAiGatewayModelManagerOptions,
+	xaiModelManagerOptions,
 } from "@oh-my-pi/pi-ai";
 import { logger } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
-import AjvModule from "ajv";
 import { type ConfigError, ConfigFile } from "../config";
 import type { ThemeColor } from "../modes/theme/theme";
-import type { AuthStorage } from "../session/auth-storage";
+import type { AuthStorage, OAuthCredential } from "../session/auth-storage";
+
+export const kNoAuth = "N/A";
+
+export function isAuthenticated(apiKey: string | undefined | null): apiKey is string {
+	return Boolean(apiKey) && apiKey !== kNoAuth;
+}
 
 export type ModelRole = "default" | "smol" | "slow" | "plan" | "commit";
 
@@ -40,8 +64,6 @@ export const MODEL_ROLES: Record<ModelRole, ModelRoleInfo> = {
 
 export const MODEL_ROLE_IDS: ModelRole[] = ["default", "smol", "slow", "plan", "commit"];
 
-const _Ajv = (AjvModule as any).default || AjvModule;
-
 const OpenRouterRoutingSchema = Type.Object({
 	only: Type.Optional(Type.Array(Type.String())),
 	order: Type.Optional(Type.Array(Type.String())),
@@ -252,19 +274,61 @@ function resolveApiKeyConfig(keyConfig: string): string | undefined {
 	return keyConfig;
 }
 
+function extractGoogleOAuthToken(value: string | undefined): string | undefined {
+	if (!isAuthenticated(value)) return undefined;
+	try {
+		const parsed = JSON.parse(value) as { token?: unknown };
+		if (Object.hasOwn(parsed, "token")) {
+			if (typeof parsed.token !== "string") {
+				return undefined;
+			}
+			const token = parsed.token.trim();
+			return token.length > 0 ? token : undefined;
+		}
+	} catch {
+		// OAuth values for Google providers are expected to be JSON, but custom setups may already provide raw token.
+	}
+	return value;
+}
+
+function getOAuthCredentialsForProvider(authStorage: AuthStorage, provider: string): OAuthCredential[] {
+	const providerEntry = authStorage.getAll()[provider];
+	if (!providerEntry) {
+		return [];
+	}
+	const entries = Array.isArray(providerEntry) ? providerEntry : [providerEntry];
+	return entries.filter((entry): entry is OAuthCredential => entry.type === "oauth");
+}
+
+function resolveOAuthAccountIdForAccessToken(
+	authStorage: AuthStorage,
+	provider: string,
+	accessToken: string,
+): string | undefined {
+	const oauthCredentials = getOAuthCredentialsForProvider(authStorage, provider);
+	const matchingCredential = oauthCredentials.find(credential => credential.access === accessToken);
+	if (matchingCredential) {
+		return matchingCredential.accountId;
+	}
+	if (oauthCredentials.length === 1) {
+		return oauthCredentials[0].accountId;
+	}
+	return undefined;
+}
+
 function mergeCompat(
 	baseCompat: Model<Api>["compat"],
 	overrideCompat: ModelOverride["compat"],
 ): Model<Api>["compat"] | undefined {
 	if (!overrideCompat) return baseCompat;
-	const base = baseCompat as any;
-	const override = overrideCompat as any;
-	const merged = { ...base, ...override };
-	if (base?.openRouterRouting || override.openRouterRouting) {
-		merged.openRouterRouting = { ...base?.openRouterRouting, ...override.openRouterRouting };
+	const base = baseCompat ?? {};
+	const override = overrideCompat;
+	const merged: NonNullable<Model<Api>["compat"]> = { ...base, ...override };
+	if (baseCompat?.openRouterRouting || overrideCompat.openRouterRouting) {
+		merged.openRouterRouting = { ...baseCompat?.openRouterRouting, ...overrideCompat.openRouterRouting };
 	}
-	if (base?.vercelGatewayRouting || override.vercelGatewayRouting) {
-		merged.vercelGatewayRouting = { ...base?.vercelGatewayRouting, ...override.vercelGatewayRouting };
+	if (baseCompat?.vercelGatewayRouting || overrideCompat.vercelGatewayRouting) {
+		merged.vercelGatewayRouting = { ...baseCompat?.vercelGatewayRouting, ...overrideCompat.vercelGatewayRouting };
 	}
 	return merged;
 }
@@ -384,8 +448,8 @@ export class ModelRegistry {
 		overrides: Map<string, ProviderOverride>,
 		modelOverrides: Map<string, Map<string, ModelOverride>>,
 	): Model<Api>[] {
-		return getProviders().flatMap(provider => {
-			const models = getModels(provider as any) as Model<Api>[];
+		return getBundledProviders().flatMap(provider => {
+			const models = getBundledModels(provider as Parameters<typeof getBundledModels>[0]) as Model<Api>[];
 			const providerOverride = overrides.get(provider);
 			const perModelOverrides = modelOverrides.get(provider);
 
@@ -516,11 +580,35 @@ export class ModelRegistry {
 	}
 
 	async #refreshRuntimeDiscoveries(): Promise<void> {
-		if (this.#discoverableProviders.length === 0) return;
-		const discovered = await Promise.all(
-			this.#discoverableProviders.map(provider => this.#discoverProviderModels(provider)),
+		const configuredDiscoveriesPromise =
+			this.#discoverableProviders.length === 0
+				? Promise.resolve<Model<Api>[]>([])
+				: Promise.all(this.#discoverableProviders.map(provider => this.#discoverProviderModels(provider))).then(
+						results => results.flat(),
+					);
+		const [configuredDiscovered, builtInDiscovered] = await Promise.all([
+			configuredDiscoveriesPromise,
+			this.#discoverBuiltInProviderModels(),
+		]);
+		const discovered = [...configuredDiscovered, ...builtInDiscovered];
+		if (discovered.length === 0) {
+			return;
+		}
+		const merged = this.#mergeCustomModels(
+			this.#models,
+			discovered.map(model => {
+				const existing =
+					this.find(model.provider, model.id) ??
+					this.#models.find(candidate => candidate.provider === model.provider);
+				return existing
+					? {
+							...model,
+							baseUrl: existing.baseUrl,
+							headers: existing.headers ? { ...existing.headers, ...model.headers } : model.headers,
+						}
+					: model;
+			}),
 		);
-		const merged = this.#mergeCustomModels(this.#models, discovered.flat());
 		this.#models = this.#applyModelOverrides(merged, this.#modelOverrides);
 	}
 
@@ -531,6 +619,208 @@ export class ModelRegistry {
 		}
 	}
 
+	async #discoverBuiltInProviderModels(): Promise<Model<Api>[]> {
+		const managerOptions = await this.#collectBuiltInModelManagerOptions();
+		if (managerOptions.length === 0) {
+			return [];
+		}
+		const discoveries = await Promise.all(managerOptions.map(options => this.#discoverWithModelManager(options)));
+		return discoveries.flat();
+	}
+
+	async #collectBuiltInModelManagerOptions(): Promise<ModelManagerOptions<Api>[]> {
+		const [
+			anthropicApiKey,
+			openaiApiKey,
+			groqApiKey,
+			cerebrasApiKey,
+			xaiApiKey,
+			mistralApiKey,
+			opencodeApiKey,
+			openrouterApiKey,
+			vercelGatewayApiKey,
+			kimiApiKey,
+			syntheticApiKey,
+			githubCopilotApiKey,
+			googleApiKey,
+			cursorApiKey,
+			googleAntigravityApiKey,
+			googleGeminiCliApiKey,
+			codexAccessToken,
+		] = await Promise.all([
+			this.getApiKeyForProvider("anthropic"),
+			this.getApiKeyForProvider("openai"),
+			this.getApiKeyForProvider("groq"),
+			this.getApiKeyForProvider("cerebras"),
+			this.getApiKeyForProvider("xai"),
+			this.getApiKeyForProvider("mistral"),
+			this.getApiKeyForProvider("opencode"),
+			this.getApiKeyForProvider("openrouter"),
+			this.getApiKeyForProvider("vercel-ai-gateway"),
+			this.getApiKeyForProvider("kimi-code"),
+			this.getApiKeyForProvider("synthetic"),
+			this.getApiKeyForProvider("github-copilot"),
+			this.getApiKeyForProvider("google"),
+			this.getApiKeyForProvider("cursor"),
+			this.getApiKeyForProvider("google-antigravity"),
+			this.getApiKeyForProvider("google-gemini-cli"),
+			this.getApiKeyForProvider("openai-codex"),
+		]);
+
+		const options: ModelManagerOptions<Api>[] = [];
+		if (isAuthenticated(anthropicApiKey)) {
+			options.push(
+				anthropicModelManagerOptions({
+					apiKey: anthropicApiKey,
+					baseUrl: this.getProviderBaseUrl("anthropic"),
+				}),
+			);
+		}
+		if (isAuthenticated(openaiApiKey)) {
+			options.push(
+				openaiModelManagerOptions({
+					apiKey: openaiApiKey,
+					baseUrl: this.getProviderBaseUrl("openai"),
+				}),
+			);
+		}
+		if (isAuthenticated(groqApiKey)) {
+			options.push(
+				groqModelManagerOptions({
+					apiKey: groqApiKey,
+					baseUrl: this.getProviderBaseUrl("groq"),
+				}),
+			);
+		}
+		if (isAuthenticated(cerebrasApiKey)) {
+			options.push(
+				cerebrasModelManagerOptions({
+					apiKey: cerebrasApiKey,
+					baseUrl: this.getProviderBaseUrl("cerebras"),
+				}),
+			);
+		}
+		if (isAuthenticated(xaiApiKey)) {
+			options.push(
+				xaiModelManagerOptions({
+					apiKey: xaiApiKey,
+					baseUrl: this.getProviderBaseUrl("xai"),
+				}),
+			);
+		}
+		if (isAuthenticated(mistralApiKey)) {
+			options.push(
+				mistralModelManagerOptions({
+					apiKey: mistralApiKey,
+					baseUrl: this.getProviderBaseUrl("mistral"),
+				}),
+			);
+		}
+		if (isAuthenticated(opencodeApiKey)) {
+			options.push(
+				opencodeModelManagerOptions({
+					apiKey: opencodeApiKey,
+					baseUrl: this.getProviderBaseUrl("opencode"),
+				}),
+			);
+		}
+		if (isAuthenticated(openrouterApiKey)) {
+			options.push(
+				openrouterModelManagerOptions({
+					apiKey: openrouterApiKey,
+					baseUrl: this.getProviderBaseUrl("openrouter"),
+				}),
+			);
+		}
+		if (isAuthenticated(vercelGatewayApiKey)) {
+			options.push(
+				vercelAiGatewayModelManagerOptions({
+					apiKey: vercelGatewayApiKey,
+					baseUrl: this.getProviderBaseUrl("vercel-ai-gateway"),
+				}),
+			);
+		}
+		if (isAuthenticated(kimiApiKey)) {
+			options.push(
+				kimiCodeModelManagerOptions({
+					apiKey: kimiApiKey,
+					baseUrl: this.getProviderBaseUrl("kimi-code"),
+				}),
+			);
+		}
+		if (isAuthenticated(syntheticApiKey)) {
+			options.push(
+				syntheticModelManagerOptions({
+					apiKey: syntheticApiKey,
+					baseUrl: this.getProviderBaseUrl("synthetic"),
+				}),
+			);
+		}
+		if (isAuthenticated(githubCopilotApiKey)) {
+			options.push(
+				githubCopilotModelManagerOptions({
+					apiKey: githubCopilotApiKey,
+					baseUrl: this.getProviderBaseUrl("github-copilot"),
+				}),
+			);
+		}
+		if (isAuthenticated(googleApiKey)) options.push(googleModelManagerOptions({ apiKey: googleApiKey }));
+		if (isAuthenticated(cursorApiKey)) {
+			options.push(
+				cursorModelManagerOptions({
+					apiKey: cursorApiKey,
+					baseUrl: this.getProviderBaseUrl("cursor"),
+				}),
+			);
+		}
+
+		const antigravityToken = extractGoogleOAuthToken(googleAntigravityApiKey);
+		if (isAuthenticated(antigravityToken)) {
+			options.push(
+				googleAntigravityModelManagerOptions({
+					oauthToken: antigravityToken,
+					endpoint: this.getProviderBaseUrl("google-antigravity"),
+				}),
+			);
+		}
+
+		const geminiCliToken = extractGoogleOAuthToken(googleGeminiCliApiKey);
+		if (isAuthenticated(geminiCliToken)) {
+			options.push(
+				googleGeminiCliModelManagerOptions({
+					oauthToken: geminiCliToken,
+					endpoint: this.getProviderBaseUrl("google-gemini-cli"),
+				}),
+			);
+		}
+
+		if (isAuthenticated(codexAccessToken)) {
+			const codexAccountId = resolveOAuthAccountIdForAccessToken(this.authStorage, "openai-codex", codexAccessToken);
+			options.push(
+				openaiCodexModelManagerOptions({
+					accessToken: codexAccessToken,
+					accountId: codexAccountId,
+				}),
+			);
+		}
+
+		return options;
+	}
+
+	async #discoverWithModelManager(options: ModelManagerOptions<Api>): Promise<Model<Api>[]> {
+		try {
+			const manager = createModelManager(options);
+			const result = await manager.refresh("online");
+			return result.models;
+		} catch (error) {
+			logger.warn("model discovery failed for provider", {
+				provider: options.providerId,
+				error: error instanceof Error ? error.message : String(error),
+			});
+			return [];
+		}
+	}
+
 	async #discoverOllamaModels(providerConfig: DiscoveryProviderConfig): Promise<Model<Api>[]> {
 		const endpoint = this.#normalizeOllamaBaseUrl(providerConfig.baseUrl);
 		const tagsUrl = `${endpoint}/api/tags`;
@@ -698,7 +988,7 @@ export class ModelRegistry {
 	 */
 	async getApiKey(model: Model<Api>, sessionId?: string): Promise<string | undefined> {
 		if (this.#keylessProviders.has(model.provider)) {
-			return "<no-auth>";
+			return kNoAuth;
 		}
 		return this.authStorage.getApiKey(model.provider, sessionId, { baseUrl: model.baseUrl });
 	}
@@ -708,7 +998,7 @@ export class ModelRegistry {
 	 */
 	async getApiKeyForProvider(provider: string, sessionId?: string, baseUrl?: string): Promise<string | undefined> {
 		if (this.#keylessProviders.has(provider)) {
-			return "<no-auth>";
+			return kNoAuth;
 		}
 		return this.authStorage.getApiKey(provider, sessionId, { baseUrl });
 	}

package/src/config/model-resolver.ts

@@ -12,7 +12,7 @@ import type { Settings } from "./settings";
 /** Default model IDs for each known provider */
 export const defaultModelPerProvider: Record<KnownProvider, string> = {
 	"amazon-bedrock": "us.anthropic.claude-opus-4-6-v1",
-	anthropic: "claude-opus-4-6",
+	anthropic: "claude-sonnet-4-6",
 	openai: "gpt-5.1-codex",
 	"openai-codex": "gpt-5.3-codex",
 	google: "gemini-2.5-pro",
@@ -20,9 +20,9 @@ export const defaultModelPerProvider: Record<KnownProvider, string> = {
 	"google-antigravity": "gemini-3-pro-high",
 	"google-vertex": "gemini-3-pro-preview",
 	"github-copilot": "gpt-4o",
-	cursor: "claude-opus-4-6",
+	cursor: "claude-sonnet-4-6",
 	openrouter: "openai/gpt-5.1-codex",
-	"vercel-ai-gateway": "anthropic/claude-opus-4-6",
+	"vercel-ai-gateway": "anthropic/claude-sonnet-4-6",
 	xai: "grok-4-fast-non-reasoning",
 	groq: "openai/gpt-oss-120b",
 	cerebras: "zai-glm-4.6",
@@ -31,8 +31,9 @@ export const defaultModelPerProvider: Record<KnownProvider, string> = {
 	minimax: "MiniMax-M2.5",
 	"minimax-code": "MiniMax-M2.5",
 	"minimax-code-cn": "MiniMax-M2.5",
-	opencode: "claude-opus-4-6",
+	opencode: "claude-sonnet-4-6",
 	"kimi-code": "kimi-k2.5",
+	synthetic: "hf:moonshotai/Kimi-K2.5",
 };
 
 export interface ScopedModel {

package/src/config/settings-schema.ts

@@ -889,6 +889,17 @@ export const SETTINGS_SCHEMA = {
 		default: "discard",
 		ui: { tab: "ttsr", label: "TTSR context mode", description: "What to do with partial output when TTSR triggers" },
 	},
+	"ttsr.interruptMode": {
+		type: "enum",
+		values: ["never", "prose-only", "tool-only", "always"] as const,
+		default: "always",
+		ui: {
+			tab: "ttsr",
+			label: "TTSR interrupt mode",
+			description: "When to interrupt mid-stream vs inject warning after completion",
+			submenu: true,
+		},
+	},
 	"ttsr.repeatMode": {
 		type: "enum",
 		values: ["once", "after-gap"] as const,
@@ -1107,6 +1118,7 @@ export interface CommitSettings {
 export interface TtsrSettings {
 	enabled: boolean;
 	contextMode: "discard" | "keep";
+	interruptMode: "never" | "prose-only" | "tool-only" | "always";
 	repeatMode: "once" | "after-gap";
 	repeatGap: number;
 }

package/src/discovery/agents.ts

@@ -1,36 +1,199 @@
 /**
  * Agents (standard) Provider
  *
- * Loads user-level skills from ~/.agents/skills.
+ * Loads user-level skills, rules, prompts, commands, context files, and system prompts from ~/.agent/.
  */
 import * as path from "node:path";
 import { registerProvider } from "../capability";
+import { type ContextFile, contextFileCapability } from "../capability/context-file";
+import { readFile } from "../capability/fs";
+import { type Prompt, promptCapability } from "../capability/prompt";
+import { type Rule, ruleCapability } from "../capability/rule";
 import { type Skill, skillCapability } from "../capability/skill";
+import { type SlashCommand, slashCommandCapability } from "../capability/slash-command";
+import { type SystemPrompt, systemPromptCapability } from "../capability/system-prompt";
 import type { LoadContext, LoadResult } from "../capability/types";
-import { loadSkillsFromDir } from "./helpers";
+import { buildRuleFromMarkdown, createSourceMeta, loadFilesFromDir, loadSkillsFromDir } from "./helpers";
 
 const PROVIDER_ID = "agents";
 const DISPLAY_NAME = "Agents (standard)";
 const PRIORITY = 70;
+const USER_AGENT_DIR_CANDIDATES = [".agent", ".agents"] as const;
 
-async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
-	const userSkillsDir = path.join(ctx.home, ".agents", "skills");
-	const result = await loadSkillsFromDir(ctx, {
-		dir: userSkillsDir,
-		providerId: PROVIDER_ID,
-		level: "user",
-	});
+function getUserAgentPathCandidates(ctx: LoadContext, ...segments: string[]): string[] {
+	return USER_AGENT_DIR_CANDIDATES.map(baseDir => path.join(ctx.home, baseDir, ...segments));
+}
 
+async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
+	const items: Skill[] = [];
+	const warnings: string[] = [];
+	for (const userSkillsDir of getUserAgentPathCandidates(ctx, "skills")) {
+		const result = await loadSkillsFromDir(ctx, {
+			dir: userSkillsDir,
+			providerId: PROVIDER_ID,
+			level: "user",
+		});
+		items.push(...result.items);
+		warnings.push(...(result.warnings ?? []));
+	}
 	return {
-		items: result.items,
-		warnings: result.warnings ?? [],
+		items,
+		warnings,
 	};
 }
 
 registerProvider<Skill>(skillCapability.id, {
 	id: PROVIDER_ID,
 	displayName: DISPLAY_NAME,
-	description: "Load skills from ~/.agents/skills",
+	description: "Load skills from ~/.agent/skills (fallback ~/.agents/skills)",
 	priority: PRIORITY,
 	load: loadSkills,
 });
+
+// Rules
+async function loadRules(ctx: LoadContext): Promise<LoadResult<Rule>> {
+	const items: Rule[] = [];
+	const warnings: string[] = [];
+	for (const userRulesDir of getUserAgentPathCandidates(ctx, "rules")) {
+		const result = await loadFilesFromDir<Rule>(ctx, userRulesDir, PROVIDER_ID, "user", {
+			extensions: ["md", "mdc"],
+			transform: (name, content, filePath, source) =>
+				buildRuleFromMarkdown(name, content, filePath, source, { stripNamePattern: /\.(md|mdc)$/ }),
+		});
+		items.push(...result.items);
+		warnings.push(...(result.warnings ?? []));
+	}
+	return {
+		items,
+		warnings,
+	};
+}
+
+registerProvider<Rule>(ruleCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: "Load rules from ~/.agent/rules (fallback ~/.agents/rules)",
+	priority: PRIORITY,
+	load: loadRules,
+});
+
+// Prompts
+async function loadPrompts(ctx: LoadContext): Promise<LoadResult<Prompt>> {
+	const items: Prompt[] = [];
+	const warnings: string[] = [];
+	for (const userPromptsDir of getUserAgentPathCandidates(ctx, "prompts")) {
+		const result = await loadFilesFromDir<Prompt>(ctx, userPromptsDir, PROVIDER_ID, "user", {
+			extensions: ["md"],
+			transform: (name, content, filePath, source) => ({
+				name: name.replace(/\.md$/, ""),
+				path: filePath,
+				content,
+				_source: source,
+			}),
+		});
+		items.push(...result.items);
+		warnings.push(...(result.warnings ?? []));
+	}
+	return {
+		items,
+		warnings,
+	};
+}
+
+registerProvider<Prompt>(promptCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: "Load prompts from ~/.agent/prompts (fallback ~/.agents/prompts)",
+	priority: PRIORITY,
+	load: loadPrompts,
+});
+
+// Slash Commands
+async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashCommand>> {
+	const items: SlashCommand[] = [];
+	const warnings: string[] = [];
+	for (const userCommandsDir of getUserAgentPathCandidates(ctx, "commands")) {
+		const result = await loadFilesFromDir<SlashCommand>(ctx, userCommandsDir, PROVIDER_ID, "user", {
+			extensions: ["md"],
+			transform: (name, content, filePath, source) => ({
+				name: name.replace(/\.md$/, ""),
+				path: filePath,
+				content,
+				level: "user",
+				_source: source,
+			}),
+		});
+		items.push(...result.items);
+		warnings.push(...(result.warnings ?? []));
+	}
+	return {
+		items,
+		warnings,
+	};
+}
+
+registerProvider<SlashCommand>(slashCommandCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: "Load commands from ~/.agent/commands (fallback ~/.agents/commands)",
+	priority: PRIORITY,
+	load: loadSlashCommands,
+});
+
+// Context Files (AGENTS.md)
+async function loadContextFiles(ctx: LoadContext): Promise<LoadResult<ContextFile>> {
+	const items: ContextFile[] = [];
+	for (const agentsPath of getUserAgentPathCandidates(ctx, "AGENTS.md")) {
+		const content = await readFile(agentsPath);
+		if (!content) {
+			continue;
+		}
+		items.push({
+			path: agentsPath,
+			content,
+			level: "user",
+			_source: createSourceMeta(PROVIDER_ID, agentsPath, "user"),
+		});
+	}
+	return {
+		items,
+		warnings: [],
+	};
+}
+
+registerProvider<ContextFile>(contextFileCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: "Load AGENTS.md from ~/.agent (fallback ~/.agents)",
+	priority: PRIORITY,
+	load: loadContextFiles,
+});
+
+// System Prompt (SYSTEM.md)
+async function loadSystemPrompt(ctx: LoadContext): Promise<LoadResult<SystemPrompt>> {
+	const items: SystemPrompt[] = [];
+	for (const systemPath of getUserAgentPathCandidates(ctx, "SYSTEM.md")) {
+		const content = await readFile(systemPath);
+		if (!content) {
+			continue;
+		}
+		items.push({
+			path: systemPath,
+			content,
+			level: "user",
+			_source: createSourceMeta(PROVIDER_ID, systemPath, "user"),
+		});
+	}
+	return {
+		items,
+		warnings: [],
+	};
+}
+
+registerProvider<SystemPrompt>(systemPromptCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: "Load SYSTEM.md from ~/.agent (fallback ~/.agents)",
+	priority: PRIORITY,
+	load: loadSystemPrompt,
+});