@phi-code-admin/phi-code 0.84.2 → 0.86.0

package/extensions/phi/models.ts

@@ -16,6 +16,7 @@
  */
 
 import { ApiKeyStore, type ConfigWatcher, type ExtensionAPI, getApiKeyStore, getConfigWatcher } from "phi-code";
+import { getModels } from "phi-code-ai";
 import {
 	buildOpenCodeGoAnthropicProviderConfig,
 	buildOpenCodeGoProviderConfig,
@@ -25,7 +26,9 @@ import { formatWindow, inferContextWindow, parseContextWindow } from "./provider
 import { fetchLiveModels, peekCache, resetLiveModelsCache, toPersistedModel } from "./providers/live-models.js";
 
 const PROVIDER_DISPLAY: Record<string, string> = {
+	opencode: "OpenCode Zen",
 	"opencode-go": "OpenCode Go",
+	"opencode-go-anthropic": "OpenCode Go (Anthropic-compat)",
 	"alibaba-codingplan": "Alibaba Coding Plan (OpenAI-compat)",
 	"alibaba-codingplan-anthropic": "Alibaba Coding Plan (Anthropic-compat)",
 	openai: "OpenAI",
@@ -37,10 +40,62 @@ const PROVIDER_DISPLAY: Record<string, string> = {
 	"lm-studio": "LM Studio (local)",
 };
 
+/**
+ * Providers the live-models dispatcher can actually re-fetch (see
+ * live-models.ts dispatchFetch + refreshOpenCodeGo). Used to extend the
+ * startup/manual refresh to providers that are authenticated via auth.json or
+ * env vars but have no models.json entry yet — without it, a user who set a
+ * key with /auth (and never ran /setup) would never see new upstream models.
+ */
+const REFRESHABLE_PROVIDERS: ReadonlySet<string> = new Set([
+	"opencode",
+	"opencode-go",
+	"opencode-go-anthropic",
+	"alibaba-codingplan",
+	"alibaba-codingplan-anthropic",
+	"openai",
+	"anthropic",
+	"google",
+	"openrouter",
+	"groq",
+	"ollama",
+	"lm-studio",
+]);
+
 function displayName(id: string): string {
 	return PROVIDER_DISPLAY[id] ?? id;
 }
 
+/** Default discovery base URLs for providers whose models.json entry is created by a refresh. */
+const DEFAULT_BASE_URLS: Record<string, string> = {
+	opencode: "https://opencode.ai/zen/v1",
+	"opencode-go": "https://opencode.ai/zen/go/v1",
+	"alibaba-codingplan": "https://coding-intl.dashscope.aliyuncs.com/v1",
+	"alibaba-codingplan-anthropic": "https://coding-intl.dashscope.aliyuncs.com/apps/anthropic",
+	openai: "https://api.openai.com/v1",
+	anthropic: "https://api.anthropic.com/v1",
+	google: "https://generativelanguage.googleapis.com/v1beta",
+	openrouter: "https://openrouter.ai/api/v1",
+	groq: "https://api.groq.com/openai/v1",
+	ollama: "http://localhost:11434/v1",
+	"lm-studio": "http://localhost:1234/v1",
+};
+
+/**
+ * Built-in (models.generated.ts) model ids for a provider. Persisting only the
+ * models NOT in this set keeps the rich built-in definitions (costs, image
+ * input, thinking-level maps) authoritative — models.json carries just the
+ * delta the static catalog does not know about yet.
+ */
+function builtinModelIds(providerId: string): Set<string> {
+	try {
+		const models = getModels(providerId as Parameters<typeof getModels>[0]) as Array<{ id: string }>;
+		return new Set(models.map((m) => m.id));
+	} catch {
+		return new Set();
+	}
+}
+
 interface RefreshOutcome {
 	provider: string;
 	source: "live" | "cache" | "fallback" | "unsupported" | "skipped";
@@ -68,7 +123,21 @@ async function refreshOpenCodeGo(
 			? buildOpenCodeGoAnthropicProviderConfig(keyForBuild, models)
 			: buildOpenCodeGoProviderConfig(keyForBuild, models);
 
-	if (config.models.length === 0) {
+	// Persist only models the built-in catalog does not know yet; built-ins stay
+	// authoritative (costs, image input) and models.json carries the delta.
+	const builtin = builtinModelIds(providerId);
+	const newModels = config.models.filter((m) => !builtin.has(m.id));
+
+	if (newModels.length === 0) {
+		if (stored && Array.isArray(stored.models) && stored.models.length > 0) {
+			// Clean up previously persisted models that have since become built-in.
+			watcher.muteForWrite("models_json_changed");
+			store.setKey(providerId, stored.apiKey ?? apiKey ?? "local", {
+				baseUrl: stored.baseUrl ?? config.baseUrl,
+				api: stored.api ?? config.api,
+				models: [],
+			});
+		}
 		return { provider: providerId, source: source === "fallback" ? "fallback" : "skipped", count: 0 };
 	}
 
@@ -76,22 +145,26 @@ async function refreshOpenCodeGo(
 	store.setKey(providerId, stored?.apiKey ?? apiKey ?? "local", {
 		baseUrl: stored?.baseUrl ?? config.baseUrl,
 		api: stored?.api ?? config.api,
-		models: config.models,
+		models: newModels,
 	});
 
 	const outcomeSource = source === "live" ? "live" : source === "cache" ? "cache" : "fallback";
-	return { provider: providerId, source: outcomeSource, count: config.models.length };
+	return { provider: providerId, source: outcomeSource, count: newModels.length };
 }
 
 async function refreshOne(
 	store: ApiKeyStore,
 	watcher: ConfigWatcher,
 	providerId: string,
+	resolvedApiKey?: string,
 ): Promise<RefreshOutcome> {
 	const stored = store.getProvider(providerId);
-	const apiKey = stored?.apiKey && !stored.apiKey.startsWith("$") && stored.apiKey !== "local"
+	const storedKey = stored?.apiKey && !stored.apiKey.startsWith("$") && stored.apiKey !== "local"
 		? stored.apiKey
 		: undefined;
+	// Prefer the key stored in models.json, else the one resolved from
+	// auth.json/env by the model registry (providers set up via /auth only).
+	const apiKey = storedKey ?? resolvedApiKey;
 
 	// OpenCode Go is a provider pair the generic fetchLiveModels path can't express
 	// (and never handled the Anthropic side), so refresh it from the shared catalog.
@@ -110,40 +183,30 @@ async function refreshOne(
 		return { provider: providerId, source: "skipped", count: 0, error: result.error };
 	}
 
-	const persisted = result.models.map(toPersistedModel);
-	if (persisted.length === 0) {
-		return { provider: providerId, source: result.source, count: 0, error: result.error };
-	}
+	// Persist only the delta the built-in catalog does not know yet (see
+	// builtinModelIds). Built-in definitions keep their costs/capabilities.
+	const builtin = builtinModelIds(providerId);
+	const persisted = result.models.map(toPersistedModel).filter((m) => !builtin.has(m.id));
 
 	// Preserve baseUrl/api/apiKey/headers from existing config; only models change.
-	const baseUrl =
-		stored?.baseUrl ??
-		(providerId === "opencode-go"
-			? "https://opencode.ai/zen/go/v1"
-			: providerId === "alibaba-codingplan"
-				? "https://coding-intl.dashscope.aliyuncs.com/v1"
-				: providerId === "alibaba-codingplan-anthropic"
-					? "https://coding-intl.dashscope.aliyuncs.com/apps/anthropic"
-					: providerId === "openai"
-						? "https://api.openai.com/v1"
-						: providerId === "anthropic"
-							? "https://api.anthropic.com/v1"
-							: providerId === "google"
-								? "https://generativelanguage.googleapis.com/v1beta"
-								: providerId === "openrouter"
-									? "https://openrouter.ai/api/v1"
-									: providerId === "groq"
-										? "https://api.groq.com/openai/v1"
-										: providerId === "ollama"
-											? "http://localhost:11434/v1"
-											: providerId === "lm-studio"
-												? "http://localhost:1234/v1"
-												: undefined);
-
+	const baseUrl = stored?.baseUrl ?? DEFAULT_BASE_URLS[providerId];
 	if (!baseUrl) {
 		return { provider: providerId, source: "skipped", count: 0, error: "unknown baseUrl" };
 	}
 
+	if (persisted.length === 0) {
+		if (stored && Array.isArray(stored.models) && stored.models.length > 0) {
+			// Clean up previously persisted models that have since become built-in.
+			watcher.muteForWrite("models_json_changed");
+			store.setKey(providerId, stored.apiKey ?? "local", {
+				baseUrl,
+				api: stored.api,
+				models: [],
+			});
+		}
+		return { provider: providerId, source: result.source, count: 0, error: result.error };
+	}
+
 	// Mute the config watcher so it does not echo this programmatic write back
 	// as a models_json_changed event (which would trigger a spurious reload +
 	// "Keys reloaded" notification). Mute per-write because refresh loops can
@@ -311,29 +374,73 @@ export default function modelsExtension(pi: ExtensionAPI) {
 		ctx.ui.notify(out, "info");
 	}
 
+	interface RefreshTarget {
+		id: string;
+		resolvedApiKey?: string;
+	}
+
+	/**
+	 * Providers to refresh: every provider persisted in models.json, plus every
+	 * refreshable provider that is authenticated (auth.json / env vars) but has
+	 * no models.json entry yet. API keys are resolved through the registry so
+	 * providers configured via /auth alone still get authenticated listings.
+	 */
+	async function resolveRefreshTargets(registry: {
+		getAvailable(): Array<{ provider: string }>;
+		getApiKeyForProvider(provider: string): Promise<string | undefined>;
+	}): Promise<RefreshTarget[]> {
+		const targets = new Map<string, RefreshTarget>();
+		for (const id of store.listProviders()) {
+			targets.set(id, { id });
+		}
+		try {
+			for (const model of registry.getAvailable()) {
+				const id = model.provider;
+				if (!targets.has(id) && REFRESHABLE_PROVIDERS.has(id)) {
+					targets.set(id, { id });
+				}
+			}
+		} catch {
+			// registry unavailable — fall back to models.json providers only
+		}
+		for (const target of targets.values()) {
+			try {
+				target.resolvedApiKey = await registry.getApiKeyForProvider(target.id);
+			} catch {
+				// no resolvable key — refreshOne will try the stored/keyless path
+			}
+		}
+		return [...targets.values()];
+	}
+
 	// Background refresh on session_start so every new Phi Code session reflects
 	// the latest provider catalogs without the user typing `/models refresh`.
 	// Failures are silent — startup must never be blocked by upstream API hiccups.
 	pi.on("session_start", async (_event, ctx) => {
+		if (process.env.PI_OFFLINE) return;
 		try {
 			store.load();
 		} catch {
 			// no models.json yet
 		}
-		const providers = store.listProviders();
-		if (providers.length === 0) return;
+		const targets = await resolveRefreshTargets(ctx.modelRegistry);
+		if (targets.length === 0) return;
 
 		// Fire-and-forget. Hot-reload via models_json_changed event surfaces results.
 		void (async () => {
-			let changed = 0;
-			for (const id of providers) {
-				const outcome = await refreshOne(store, watcher, id).catch(() => undefined);
-				if (outcome && outcome.source === "live" && outcome.count > 0) changed++;
+			let discovered = 0;
+			let changedProviders = 0;
+			for (const target of targets) {
+				const outcome = await refreshOne(store, watcher, target.id, target.resolvedApiKey).catch(() => undefined);
+				if (outcome && outcome.source === "live" && outcome.count > 0) {
+					changedProviders++;
+					discovered += outcome.count;
+				}
 			}
-			if (changed > 0) {
+			if (changedProviders > 0) {
 				try {
 					ctx.ui.notify(
-						`Refreshed ${changed}/${providers.length} provider catalog(s) in the background.`,
+						`Discovered ${discovered} new model(s) across ${changedProviders} provider(s). See /model.`,
 						"info",
 					);
 				} catch {
@@ -346,20 +453,33 @@ export default function modelsExtension(pi: ExtensionAPI) {
 
 	async function refreshCommand(
 		target: string | undefined,
-		ctx: { ui: { notify: (m: string, t?: "info" | "warning" | "error") => void; setStatus?: (k: string, v?: string) => void } },
+		ctx: {
+			ui: { notify: (m: string, t?: "info" | "warning" | "error") => void; setStatus?: (k: string, v?: string) => void };
+			modelRegistry: {
+				getAvailable(): Array<{ provider: string }>;
+				getApiKeyForProvider(provider: string): Promise<string | undefined>;
+			};
+		},
 	): Promise<void> {
-		const providers = target ? [target] : store.listProviders();
-		if (providers.length === 0) {
+		const targets = target ? [{ id: target } as RefreshTarget] : await resolveRefreshTargets(ctx.modelRegistry);
+		if (target) {
+			try {
+				targets[0].resolvedApiKey = await ctx.modelRegistry.getApiKeyForProvider(target);
+			} catch {
+				// keep undefined
+			}
+		}
+		if (targets.length === 0) {
 			ctx.ui.notify("No providers configured.", "warning");
 			return;
 		}
-		ctx.ui.notify(`Refreshing ${providers.length} provider(s)...`, "info");
+		ctx.ui.notify(`Refreshing ${targets.length} provider(s)...`, "info");
 		ctx.ui.setStatus?.("models-refresh", "Fetching live model catalogs...");
 
 		const outcomes: RefreshOutcome[] = [];
-		for (const id of providers) {
-			const outcome = await refreshOne(store, watcher, id).catch((err) => ({
-				provider: id,
+		for (const t of targets) {
+			const outcome = await refreshOne(store, watcher, t.id, t.resolvedApiKey).catch((err) => ({
+				provider: t.id,
 				source: "skipped" as const,
 				count: 0,
 				error: err instanceof Error ? err.message : String(err),
@@ -371,9 +491,10 @@ export default function modelsExtension(pi: ExtensionAPI) {
 		let out = "**Refresh report:**\n";
 		for (const o of outcomes) {
 			const icon = o.source === "live" ? "[ok]" : o.source === "fallback" ? "[fb]" : o.source === "cache" ? "[c]" : "[--]";
-			out += `  ${icon} ${displayName(o.provider)} \`${o.provider}\` — ${o.count} model(s) (${o.source}${o.error ? `, ${o.error}` : ""})\n`;
+			out += `  ${icon} ${displayName(o.provider)} \`${o.provider}\` — ${o.count} new model(s) (${o.source}${o.error ? `, ${o.error}` : ""})\n`;
 		}
-		out += `\nModels persisted to \`${store.configPath}\`. \`/model\` picker now reflects this catalog.`;
+		out += `\nOnly models missing from the built-in catalog are persisted to \`${store.configPath}\`;\n`;
+		out += `built-in models stay available either way. \`/model\` picker reflects the merged catalog.`;
 		ctx.ui.notify(out, "info");
 		pi.events.emit("models_json_changed", { source: "models-refresh" });
 	}

package/extensions/phi/orchestrator.ts

@@ -29,6 +29,7 @@ import {
 	parsePhaseVerdict,
 } from "./providers/orchestrator-helpers.js";
 import { defaultExplorerSpecs, READONLY_EXPLORER_TOOLS, runExploreFanout } from "./providers/explore-fanout.js";
+import { type AgentDef, loadAgentDef } from "./providers/agent-def.js";
 
 // ─── Types ───────────────────────────────────────────────────────────────
 
@@ -212,12 +213,6 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 
 	// ─── Orchestration State ─────────────────────────────────────────
 
-	interface AgentDef {
-		name: string;
-		tools: string[];
-		systemPrompt: string;
-	}
-
 	interface OrchestratorPhase {
 		key: string;
 		label: string;
@@ -331,30 +326,25 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 - **Internal orchestration data:** notes injected as "Previous phase summary" or budget/handoff reminders are for YOUR use only. Do not repeat them back to the user.`;
 
 	/**
-	 * Parse agent .md file with YAML frontmatter
+	 * Load a skill body (SKILL.md) so a phase instruction can embed it verbatim.
+	 * Search order mirrors agent-def.ts: project .phi/skills, then the global
+	 * ~/.phi/agent/skills (postinstall copies bundled skills there), then the
+	 * bundled <package>/skills for the repo layout. YAML frontmatter is
+	 * stripped. Returns null when the skill is not installed.
 	 */
-	function loadAgentDef(name: string): AgentDef | null {
+	function loadSkillContent(name: string): string | null {
 		const dirs = [
-			join(process.cwd(), ".phi", "agents"),
-			join(homedir(), ".phi", "agent", "agents"),
+			join(process.cwd(), ".phi", "skills"),
+			join(homedir(), ".phi", "agent", "skills"),
+			join(__dirname, "..", "..", "skills"),
 		];
 		for (const dir of dirs) {
-			const filePath = join(dir, `${name}.md`);
 			try {
-				const content = readFileSync(filePath, "utf-8");
-				const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
-				if (!fmMatch) continue;
-				const fields: Record<string, string> = {};
-				for (const line of fmMatch[1].split("\n")) {
-					const m = line.match(/^(\w+):\s*(.*)$/);
-					if (m) fields[m[1]] = m[2].trim();
-				}
-				return {
-					name: fields.name || name,
-					tools: (fields.tools || "").split(",").map(t => t.trim()).filter(Boolean),
-					systemPrompt: fmMatch[2].trim(),
-				};
-			} catch { continue; }
+				const content = readFileSync(join(dir, name, "SKILL.md"), "utf-8");
+				const fmMatch = content.match(/^---\s*\n[\s\S]*?\n---\s*\n([\s\S]*)$/);
+				const body = (fmMatch ? fmMatch[1] : content).trim();
+				if (body) return body;
+			} catch { /* try next dir */ }
 		}
 		return null;
 	}
@@ -392,6 +382,15 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 			: '';
 		const runtimeInfo = `\n\nRuntime: ${process.platform} (${process.arch})${shellNote}`;
 
+		// Embed the prompt-architect skill so the PLAN phase applies it to every
+		// task it writes. The skill ships bundled and is copied to
+		// ~/.phi/agent/skills by postinstall; when missing, the inline task format
+		// still enforces the [CONTEXT]/[TASK]/[FORMAT]/[CONSTRAINTS] structure.
+		const promptArchitectSkill = loadSkillContent("prompt-architect");
+		const promptArchitectSection = promptArchitectSkill
+			? `\n**Prompt-architect skill (apply it to every task you write):**\n\n${promptArchitectSkill}\n`
+			: "";
+
 		const phases: OrchestratorPhase[] = [
 			{
 				key: "explore", label: "🔍 Phase 1 — EXPLORE", model: explore.preferred, fallback: explore.fallback,
@@ -466,29 +465,37 @@ After your analysis, use \`ontology_add\` to save key project entities AND their
 **Step 1:** Read \`.phi/plans/brief-*.md\` (created by the explore phase)
 **Step 2:** Read \`.phi/plans/explore-*.md\` to understand the codebase analysis
 **Step 3:** Design the architecture based on findings
-**Step 4:** Create a DETAILED TODO LIST in \`.phi/plans/todo-${ts}.md\`:
-   For each task:
-   - Task number and title
-   - Agent assignment (code/test)
-   - Files to create/modify
-   - Specific implementation details
-   - Dependencies on other tasks
+**Step 4:** Create a DETAILED TODO LIST in \`.phi/plans/todo-${ts}.md\`.
+   Every task is a PROMPT for the CODE agent, which starts with ZERO memory of
+   this conversation. Write each task with the prompt-architect structure:
+   - **[CONTEXT]** what exists and why this task (real paths from the explore phase)
+   - **[TASK]** exactly what to do — files to create/modify with full paths
+   - **[FORMAT]** expected deliverable — exports, signatures, style, tests
+   - **[CONSTRAINTS]** what NOT to break, patterns to respect
+   Plus: task number + title, agent assignment (code/test), dependencies.
 
 **Format for the todo list:**
 \`\`\`markdown
 # TODO: Project Tasks
 
 ## Task 1: [Task Title] [agent-type]
-- [ ] Specific implementation details
-- [ ] Files to create: path/to/file.ext
-- [ ] Expected behavior
+**[CONTEXT]** [What exists now, why this task, real paths (src/x.ts:42)]
+**[TASK]**
+- [ ] Create path/to/file.ext with [specific behavior]
+- [ ] Modify path/to/other.ext: [exact change]
+**[FORMAT]** [Expected exports/signatures/tests]
+**[CONSTRAINTS]** [What not to break, patterns to follow]
 - Dependencies: None
 
 ## Task 2: [Task Title] [agent-type]
-- [ ] Implementation details
+**[CONTEXT]** ...
+**[TASK]**
+- [ ] ...
+**[FORMAT]** ...
+**[CONSTRAINTS]** ...
 - Dependencies: Task 1
 \`\`\`
-
+${promptArchitectSection}
 Before finishing, use \`memory_write\` to save your plan summary with relevant tags for future reference.` + runtimeInfo + COMMON_PHASE_RULES,
 			},
 			{

package/extensions/phi/providers/agent-def.ts

@@ -0,0 +1,128 @@
+/**
+ * Agent definitions (.md with YAML frontmatter) — single source of truth for
+ * parsing and discovery, shared by the /plan orchestrator (loadAgentDef) and
+ * the /agents command (discoverAgents). Before this module existed the two
+ * call sites each had their own parser and they had already drifted.
+ *
+ * Search order (first match wins):
+ *   1. <cwd>/.phi/agents/           (project)
+ *   2. ~/.phi/agent/agents/         (global — postinstall copies bundled here)
+ *   3. <package>/agents/            (bundled, repo layout)
+ *
+ * Layout note: this file lives in extensions/phi/providers/. Three hops up is
+ * the package root in the repo layout (packages/coding-agent) AND the agent
+ * dir in the installed layout (~/.phi/agent), so the "bundled" candidate
+ * resolves to a real agents/ directory in both.
+ */
+
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+
+export type AgentSource = "project" | "global" | "bundled";
+
+export interface AgentDef {
+	name: string;
+	description: string;
+	tools: string[];
+	model: string;
+	systemPrompt: string;
+	filePath: string;
+	source: AgentSource;
+}
+
+/**
+ * Parse an agent .md file: YAML frontmatter (name, description, tools, model)
+ * followed by the system prompt body. `tools` is a comma-separated list.
+ * Returns null when the file has no frontmatter block.
+ */
+export function parseAgentMarkdown(content: string, filePath: string, source: AgentSource): AgentDef | null {
+	const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
+	if (!fmMatch) return null;
+
+	const fields: Record<string, string> = {};
+	for (const line of fmMatch[1].split("\n")) {
+		const m = line.match(/^(\w+):\s*(.*)$/);
+		if (m) fields[m[1]] = m[2].trim();
+	}
+
+	const name = fields.name || basename(filePath).replace(/\.md$/, "");
+	if (!name) return null;
+
+	return {
+		name,
+		description: fields.description || "No description",
+		tools: (fields.tools || "")
+			.split(",")
+			.map((t) => t.trim())
+			.filter(Boolean),
+		model: fields.model || "default",
+		systemPrompt: fmMatch[2].trim(),
+		filePath,
+		source,
+	};
+}
+
+function readAgentFile(filePath: string, source: AgentSource): AgentDef | null {
+	try {
+		return parseAgentMarkdown(readFileSync(filePath, "utf-8"), filePath, source);
+	} catch {
+		return null;
+	}
+}
+
+/** Agent directories in precedence order (project > global > bundled). */
+export function agentSearchDirs(cwd: string = process.cwd()): Array<{ dir: string; source: AgentSource }> {
+	return [
+		{ dir: join(cwd, ".phi", "agents"), source: "project" },
+		{ dir: join(homedir(), ".phi", "agent", "agents"), source: "global" },
+		{ dir: join(__dirname, "..", "..", "..", "agents"), source: "bundled" },
+	];
+}
+
+/**
+ * Load a single agent definition by name. Used by the /plan orchestrator to
+ * activate a phase persona.
+ */
+export function loadAgentDef(name: string, cwd: string = process.cwd()): AgentDef | null {
+	for (const { dir, source } of agentSearchDirs(cwd)) {
+		const def = readAgentFile(join(dir, `${name}.md`), source);
+		if (def) return def;
+	}
+	return null;
+}
+
+/**
+ * Discover every agent definition across all sources, first match per name
+ * wins. Used by the /agents command.
+ */
+export function discoverAgents(cwd: string = process.cwd()): AgentDef[] {
+	const seen = new Set<string>();
+	const agents: AgentDef[] = [];
+
+	for (const { dir, source } of agentSearchDirs(cwd)) {
+		if (!existsSync(dir)) continue;
+		let entries: string[];
+		try {
+			entries = readdirSync(dir);
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			if (!entry.endsWith(".md")) continue;
+			const filePath = join(dir, entry);
+			try {
+				if (!statSync(filePath).isFile()) continue;
+			} catch {
+				continue;
+			}
+			const def = readAgentFile(filePath, source);
+			if (def && !seen.has(def.name)) {
+				seen.add(def.name);
+				agents.push(def);
+			}
+		}
+	}
+
+	return agents;
+}

package/extensions/phi/providers/live-models.ts

@@ -27,7 +27,7 @@ import {
 import { ALIBABA_MODELS, ALIBABA_PROVIDERS, pingAlibaba } from "./alibaba.js";
 import { inferContextWindow } from "./context-window.js";
 
-export const LAST_VERIFIED = "2026-05-15";
+export const LAST_VERIFIED = "2026-07-10";
 
 export interface LiveModel {
 	id: string;
@@ -203,8 +203,27 @@ const STATIC_OPENROUTER: LiveModel[] = [
 	{ id: "minimax/MiniMax-M2.7", name: "MiniMax M2.7", reasoning: true },
 ];
 
+// OpenCode Zen (https://opencode.ai/zen) — the non-Go catalog. The models
+// endpoint is reachable without a key (like OpenRouter); inference needs one.
+const STATIC_OPENCODE_ZEN: LiveModel[] = [
+	{ id: "claude-fable-5", name: "Claude Fable 5", contextWindow: 200_000, reasoning: true },
+	{ id: "claude-opus-4-8", name: "Claude Opus 4.8", contextWindow: 200_000, reasoning: true },
+	{ id: "claude-sonnet-5", name: "Claude Sonnet 5", contextWindow: 200_000, reasoning: true },
+	{ id: "claude-haiku-4-5", name: "Claude Haiku 4.5", contextWindow: 200_000, reasoning: true },
+	{ id: "gemini-3.5-flash", name: "Gemini 3.5 Flash", contextWindow: 1_000_000, reasoning: true },
+	{ id: "gemini-3.1-pro", name: "Gemini 3.1 Pro", contextWindow: 1_000_000, reasoning: true },
+	{ id: "gpt-5.5", name: "GPT-5.5", contextWindow: 400_000, reasoning: true },
+	{ id: "gpt-5.4", name: "GPT-5.4", contextWindow: 400_000, reasoning: true },
+	{ id: "glm-5.2", name: "GLM 5.2", contextWindow: 200_000, reasoning: true },
+	{ id: "glm-5.1", name: "GLM 5.1", contextWindow: 200_000, reasoning: true },
+	{ id: "kimi-k2.6", name: "Kimi K2.6", contextWindow: 256_000, reasoning: true },
+	{ id: "minimax-m2.7", name: "MiniMax M2.7", contextWindow: 1_000_000, reasoning: true },
+];
+
 function staticFallbackFor(providerId: string): LiveModel[] {
 	switch (providerId) {
+		case "opencode":
+			return STATIC_OPENCODE_ZEN;
 		case "opencode-go":
 			return OPENCODE_GO_FALLBACK_MODELS.map((m) => ({
 				id: m.id,
@@ -274,6 +293,15 @@ async function fetchOpenRouter(apiKey: string | undefined, timeoutMs: number): P
 	return mapOpenAIModels(raw);
 }
 
+async function fetchOpenCodeZen(apiKey: string | undefined, timeoutMs: number): Promise<LiveModel[]> {
+	const headers: Record<string, string> = { Accept: "application/json" };
+	if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+	const raw = (await fetchJson("https://opencode.ai/zen/v1/models", headers, timeoutMs)) as OpenAIModelsResponse;
+	// The Zen endpoint reports neither context windows nor reasoning support;
+	// frontier catalog models all expose reasoning, so default to true.
+	return mapOpenAIModels(raw).map((m) => ({ ...m, reasoning: true }));
+}
+
 async function fetchGroq(apiKey: string, timeoutMs: number): Promise<LiveModel[]> {
 	const raw = (await fetchJson(
 		"https://api.groq.com/openai/v1/models",
@@ -351,6 +379,8 @@ async function dispatchFetch(providerId: string, options: FetchOptions): Promise
 			return await fetchGoogle(apiKey, timeoutMs);
 		case "openrouter":
 			return await fetchOpenRouter(apiKey, timeoutMs);
+		case "opencode":
+			return await fetchOpenCodeZen(apiKey, timeoutMs);
 		case "groq":
 			if (!apiKey) throw new Error("Groq requires an API key for live listing");
 			return await fetchGroq(apiKey, timeoutMs);