@oh-my-pi/pi-coding-agent 13.17.0 → 13.17.5

package/src/config/model-registry.ts

@@ -31,7 +31,7 @@ import { type ConfigError, ConfigFile } from "../config";
 import { parseModelString } from "../config/model-resolver";
 import { isValidThemeColor, type ThemeColor } from "../modes/theme/theme";
 import type { AuthStorage, OAuthCredential } from "../session/auth-storage";
-import type { Settings } from "./settings";
+import { type Settings, settings } from "./settings";
 
 export const kNoAuth = "N/A";
 
@@ -730,6 +730,14 @@ function normalizeSuppressedSelector(selector: string): string {
 	return `${parsed.provider}/${parsed.id}`;
 }
 
+function getDisabledProviderIdsFromSettings(): Set<string> {
+	try {
+		return new Set(settings.get("disabledProviders"));
+	} catch {
+		return new Set();
+	}
+}
+
 /**
  * Model registry - loads and manages models, resolves API keys via AuthStorage.
  */
@@ -1670,11 +1678,19 @@ export class ModelRegistry {
 	 * This is a fast check that doesn't refresh OAuth tokens.
 	 */
 	getAvailable(): Model<Api>[] {
-		return this.#models.filter(m => this.#keylessProviders.has(m.provider) || this.authStorage.hasAuth(m.provider));
+		const disabledProviders = getDisabledProviderIdsFromSettings();
+		return this.#models.filter(
+			m =>
+				!disabledProviders.has(m.provider) &&
+				(this.#keylessProviders.has(m.provider) || this.authStorage.hasAuth(m.provider)),
+		);
 	}
 
 	getDiscoverableProviders(): string[] {
-		return this.#discoverableProviders.map(provider => provider.provider);
+		const disabledProviders = getDisabledProviderIdsFromSettings();
+		return this.#discoverableProviders
+			.filter(provider => !disabledProviders.has(provider.provider))
+			.map(provider => provider.provider);
 	}
 
 	getProviderDiscoveryState(provider: string): ProviderDiscoveryState | undefined {

package/src/config/model-resolver.ts

@@ -587,6 +587,27 @@ export function resolveModelOverride(
 	return { explicitThinkingLevel: false };
 }
 
+/**
+ * Resolve a list of role patterns to the first matching model.
+ */
+export function resolveRoleSelection(
+	roles: readonly string[],
+	settings: Settings,
+	availableModels: Model<Api>[],
+): { model: Model<Api>; thinkingLevel?: ThinkingLevel } | undefined {
+	const matchPreferences = { usageOrder: settings.getStorage()?.getModelUsageOrder() };
+	for (const role of roles) {
+		const resolved = resolveModelRoleValue(settings.getModelRole(role), availableModels, {
+			settings,
+			matchPreferences,
+		});
+		if (resolved.model) {
+			return { model: resolved.model, thinkingLevel: resolved.thinkingLevel };
+		}
+	}
+	return undefined;
+}
+
 /**
  * Resolve model patterns to actual Model objects with optional thinking levels
  * Format: "pattern:level" where :level is optional

package/src/config/settings-schema.ts

@@ -372,6 +372,12 @@ export const SETTINGS_SCHEMA = {
 			"Maximum width in terminal columns for inline images (default 100). Set to 0 for unlimited (bounded only by terminal width).",
 	},
 
+	"tui.maxInlineImageRows": {
+		type: "number",
+		default: 20,
+		description:
+			"Maximum height in terminal rows for inline images (default 20). Set to 0 to use only the viewport-based limit (60% of terminal height).",
+	},
 	// Display rendering
 	"display.tabWidth": {
 		type: "number",
@@ -1204,6 +1210,16 @@ export const SETTINGS_SCHEMA = {
 		ui: { tab: "tools", label: "Fetch", description: "Enable the fetch tool for URL fetching" },
 	},
 
+	"github.enabled": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "tools",
+			label: "GitHub CLI",
+			description: "Enable read-only gh_* tools for GitHub repository, issue, pull request, diff, and search access",
+		},
+	},
+
 	"web_search.enabled": {
 		type: "boolean",
 		default: true,

package/src/discovery/claude-plugins.ts

@@ -36,7 +36,7 @@ async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
 	const items: Skill[] = [];
 	const warnings: string[] = [];
 
-	const { roots, warnings: rootWarnings } = await listClaudePluginRoots(ctx.home);
+	const { roots, warnings: rootWarnings } = await listClaudePluginRoots(ctx.home, ctx.cwd);
 	warnings.push(...rootWarnings);
 
 	const results = await Promise.all(
@@ -70,7 +70,7 @@ async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashComm
 	const items: SlashCommand[] = [];
 	const warnings: string[] = [];
 
-	const { roots, warnings: rootWarnings } = await listClaudePluginRoots(ctx.home);
+	const { roots, warnings: rootWarnings } = await listClaudePluginRoots(ctx.home, ctx.cwd);
 	warnings.push(...rootWarnings);
 
 	const results = await Promise.all(
@@ -108,7 +108,7 @@ async function loadHooks(ctx: LoadContext): Promise<LoadResult<Hook>> {
 	const items: Hook[] = [];
 	const warnings: string[] = [];
 
-	const { roots, warnings: rootWarnings } = await listClaudePluginRoots(ctx.home);
+	const { roots, warnings: rootWarnings } = await listClaudePluginRoots(ctx.home, ctx.cwd);
 	warnings.push(...rootWarnings);
 
 	const hookTypes = ["pre", "post"] as const;
@@ -155,7 +155,7 @@ async function loadTools(ctx: LoadContext): Promise<LoadResult<CustomTool>> {
 	const items: CustomTool[] = [];
 	const warnings: string[] = [];
 
-	const { roots, warnings: rootWarnings } = await listClaudePluginRoots(ctx.home);
+	const { roots, warnings: rootWarnings } = await listClaudePluginRoots(ctx.home, ctx.cwd);
 	warnings.push(...rootWarnings);
 
 	const results = await Promise.all(
@@ -192,7 +192,7 @@ async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>>
 	const items: MCPServer[] = [];
 	const warnings: string[] = [];
 
-	const { roots, warnings: rootWarnings } = await listClaudePluginRoots(ctx.home);
+	const { roots, warnings: rootWarnings } = await listClaudePluginRoots(ctx.home, ctx.cwd);
 	warnings.push(...rootWarnings);
 
 	for (const root of roots) {

package/src/discovery/helpers.ts

@@ -1,8 +1,9 @@
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { FileType, glob } from "@oh-my-pi/pi-natives";
-import { CONFIG_DIR_NAME, getConfigDirName, tryParseJson } from "@oh-my-pi/pi-utils";
+import { CONFIG_DIR_NAME, getConfigDirName, getProjectDir, tryParseJson } from "@oh-my-pi/pi-utils";
 import { readDirEntries, readFile } from "../capability/fs";
 import { parseRuleConditionAndScope, type Rule, type RuleFrontmatter } from "../capability/rule";
 import type { Skill, SkillFrontmatter } from "../capability/skill";
@@ -640,19 +641,96 @@ export function parseClaudePluginsRegistry(content: string): ClaudePluginsRegist
 }
 
 /**
- * List all installed Claude Code plugin roots from the plugin cache.
- * Reads ~/.claude/plugins/installed_plugins.json and resolves plugin paths.
+ * Resolve the active project registry path by walking up from `cwd`.
+ *
+ * Walk order:
+ * 1. Walk up from `cwd` looking for the nearest directory containing `.omp/`.
+ *    The first match returns `<dir>/.omp/plugins/installed_plugins.json`.
+ * 2. If no `.omp/` is found, rescan from `cwd` upward looking for `.git`.
+ *    The git root is used as an anchor: `<gitRoot>/.omp/plugins/installed_plugins.json`.
+ * 3. If neither is found, return `null` — no project context is active.
  *
- * Results are cached per home directory to avoid repeated parsing.
+ * This is the single source of truth for "active project root" used by install,
+ * uninstall, list, upgrade, discovery, and doctor. Deterministic for a given `cwd`.
  */
+export async function resolveActiveProjectRegistryPath(cwd: string): Promise<string | null> {
+	// Pass 1: walk up looking for an existing .omp/ directory (nearest wins).
+	// Stop before os.homedir() — ~/.omp/ is the user-level config dir, not a project root.
+	const homeDir = os.homedir();
+	let dir = path.resolve(cwd);
+	while (dir !== homeDir) {
+		try {
+			const stat = await fs.promises.stat(path.join(dir, getConfigDirName()));
+			if (stat.isDirectory()) {
+				return path.join(dir, getConfigDirName(), "plugins", "installed_plugins.json");
+			}
+		} catch {
+			// not found at this level — continue up
+		}
+		const parent = path.dirname(dir);
+		if (parent === dir) break; // filesystem root
+		dir = parent;
+	}
+
+	// Pass 2: walk up looking for .git as a fallback anchor.
+	dir = path.resolve(cwd);
+	while (dir !== homeDir) {
+		try {
+			await fs.promises.stat(path.join(dir, ".git"));
+			return path.join(dir, getConfigDirName(), "plugins", "installed_plugins.json");
+		} catch {
+			// not found at this level — continue up
+		}
+		const parent = path.dirname(dir);
+		if (parent === dir) break; // filesystem root
+		dir = parent;
+	}
+
+	return null; // not inside any project
+}
+
+/**
+ * Like resolveActiveProjectRegistryPath, but falls back to `<cwd>/.omp/plugins/installed_plugins.json`
+ * when no project anchor (.omp/ or .git/) is found.
+ *
+ * Use this when the caller accepts an explicit --scope project so that installing into a freshly
+ * bootstrapped directory (no .omp/ or .git/ yet) works: writeInstalledPluginsRegistry auto-creates
+ * the directory tree on first write.
+ *
+ * Returns undefined when cwd is os.homedir() — that path is already the user registry and must
+ * never alias as the project registry.
+ */
+export async function resolveOrDefaultProjectRegistryPath(cwd: string): Promise<string | undefined> {
+	const resolved = await resolveActiveProjectRegistryPath(cwd);
+	if (resolved) return resolved;
+	// Home directory must not be treated as a project root: the fallback path would alias
+	// getInstalledPluginsRegistryPath(), causing MarketplaceManager to load the same file
+	// as both user and project registry and producing duplicates / disambiguation errors.
+	if (path.resolve(cwd) === os.homedir()) return undefined;
+	return path.join(cwd, getConfigDirName(), "plugins", "installed_plugins.json");
+}
+
 const pluginRootsCache = new Map<string, { roots: ClaudePluginRoot[]; warnings: string[] }>();
 
-export async function listClaudePluginRoots(home: string): Promise<{ roots: ClaudePluginRoot[]; warnings: string[] }> {
-	const cached = pluginRootsCache.get(home);
+/**
+ * List all installed Claude Code plugin roots from the plugin cache.
+ * Reads ~/.claude/plugins/installed_plugins.json and ~/.omp/plugins/installed_plugins.json,
+ * and optionally the nearest project-scoped registry resolved from `cwd`.
+ *
+ * Results are cached per `home:resolvedProjectPath` key to avoid repeated parsing.
+ */
+export async function listClaudePluginRoots(
+	home: string,
+	cwd?: string,
+): Promise<{ roots: ClaudePluginRoot[]; warnings: string[] }> {
+	const resolvedProjectPath = cwd ? await resolveActiveProjectRegistryPath(cwd) : null;
+	const cacheKey = `${home}:${resolvedProjectPath ?? ""}`;
+	const cached = pluginRootsCache.get(cacheKey);
 	if (cached) return cached;
 
 	const roots: ClaudePluginRoot[] = [];
 	const warnings: string[] = [];
+	const projectRoots: ClaudePluginRoot[] = [];
 
 	// ── Claude Code registry ──────────────────────────────────────────────────
 	const registryPath = path.join(home, ".claude", "plugins", "installed_plugins.json");
@@ -746,6 +824,53 @@ export async function listClaudePluginRoots(home: string): Promise<{ roots: Clau
 		}
 	}
 
+	// ── Project-scoped OMP registry ────────────────────────────────────────
+	// Loaded from the nearest .omp/plugins/installed_plugins.json relative to cwd.
+	// Project entries take precedence over user entries for the same plugin ID.
+	if (resolvedProjectPath) {
+		const projectContent = await readFile(resolvedProjectPath);
+		if (projectContent) {
+			const projectRegistry = parseClaudePluginsRegistry(projectContent);
+			if (projectRegistry) {
+				for (const [pluginId, entries] of Object.entries(projectRegistry.plugins)) {
+					if (!Array.isArray(entries) || entries.length === 0) continue;
+					const atIndex = pluginId.lastIndexOf("@");
+					if (atIndex === -1) {
+						warnings.push(`Invalid plugin ID format (missing @marketplace): ${pluginId}`);
+						continue;
+					}
+					const pluginName = pluginId.slice(0, atIndex);
+					const marketplace = pluginId.slice(atIndex + 1);
+					for (const entry of entries) {
+						if (!entry.installPath || typeof entry.installPath !== "string") {
+							warnings.push(`Plugin ${pluginId} entry has no installPath`);
+							continue;
+						}
+						if (entry.enabled === false) continue;
+						projectRoots.push({
+							id: pluginId,
+							marketplace,
+							plugin: pluginName,
+							version: entry.version || "unknown",
+							path: entry.installPath,
+							scope: "project",
+						});
+					}
+				}
+			} else {
+				warnings.push(`Failed to parse project plugin registry: ${resolvedProjectPath}`);
+			}
+		}
+	}
+
+	// Project entries shadow user entries for the same plugin ID.
+	if (projectRoots.length > 0) {
+		const projectIds = new Set(projectRoots.map(r => r.id));
+		const deduped = roots.filter(r => !projectIds.has(r.id));
+		roots.length = 0;
+		roots.push(...projectRoots, ...deduped);
+	}
+
 	// Merge --plugin-dir roots (highest precedence) on every fresh load
 	if (injectedPluginDirRoots.length > 0) {
 		const injectedIds = new Set(injectedPluginDirRoots.map(r => r.id));
@@ -755,7 +880,7 @@ export async function listClaudePluginRoots(home: string): Promise<{ roots: Clau
 	}
 
 	const result = { roots, warnings };
-	pluginRootsCache.set(home, result);
+	pluginRootsCache.set(cacheKey, result);
 	return result;
 }
 
@@ -767,7 +892,7 @@ export function clearClaudePluginRootsCache(): void {
 	preloadedPluginRoots = [...injectedPluginDirRoots];
 	// Re-warm preloaded roots asynchronously so sync LSP config reads stay valid
 	if (lastPreloadHome) {
-		void preloadPluginRoots(lastPreloadHome);
+		void preloadPluginRoots(lastPreloadHome, getProjectDir());
 	}
 }
 
@@ -784,9 +909,9 @@ let lastPreloadHome: string | undefined;
  * Call during session initialization, after dir resolution completes
  * but before any LSP config is read.
  */
-export async function preloadPluginRoots(home: string): Promise<void> {
+export async function preloadPluginRoots(home: string, cwd?: string): Promise<void> {
 	lastPreloadHome = home;
-	const { roots } = await listClaudePluginRoots(home);
+	const { roots } = await listClaudePluginRoots(home, cwd);
 	preloadedPluginRoots = roots;
 }
 
@@ -805,10 +930,7 @@ export function getPreloadedPluginRoots(): readonly ClaudePluginRoot[] {
  * These are prepended to the cache with highest precedence (before OMP/Claude entries).
  * Must be called before any listClaudePluginRoots() access.
  */
-export async function injectPluginDirRoots(home: string, dirs: string[]): Promise<void> {
-	// Ensure the base cache is populated first
-	const { roots, warnings } = await listClaudePluginRoots(home);
-
+export async function injectPluginDirRoots(home: string, dirs: string[], cwd?: string): Promise<void> {
 	const injected: ClaudePluginRoot[] = [];
 	for (const dir of dirs) {
 		const resolved = path.resolve(dir);
@@ -828,15 +950,13 @@ export async function injectPluginDirRoots(home: string, dirs: string[]): Promis
 		injected.push(buildPluginDirRoot(resolved, pluginName));
 	}
 
-	// --plugin-dir roots have highest precedence: prepend them,
-	// removing any existing entries with the same plugin ID.
+	// Set injected roots BEFORE populating cache so listClaudePluginRoots merges them.
 	injectedPluginDirRoots = injected;
-
-	const injectedIds = new Set(injected.map(r => r.id));
-	const filtered = roots.filter(r => !injectedIds.has(r.id));
-	const merged = [...injected, ...filtered];
-
-	// Replace the cache entry
-	pluginRootsCache.set(home, { roots: merged, warnings });
-	preloadedPluginRoots = merged;
+	lastPreloadHome = home; // ensure cache-clear re-warm fires even when injectPluginDirRoots was the startup path
+	// Clear any stale cache entries (populated before injected roots were set).
+	pluginRootsCache.clear();
+	// Rebuild — cache miss triggers fresh load that includes both user+project registries
+	// and prepends injectedPluginDirRoots at highest precedence.
+	const { roots } = await listClaudePluginRoots(home, cwd);
+	preloadedPluginRoots = roots;
 }

package/src/extensibility/custom-commands/bundled/ci-green/index.ts

@@ -0,0 +1,37 @@
+import { renderPromptTemplate } from "../../../../config/prompt-templates";
+import type { CustomCommand, CustomCommandAPI } from "../../../../extensibility/custom-commands/types";
+import type { HookCommandContext } from "../../../../extensibility/hooks/types";
+import ciGreenRequestTemplate from "../../../../prompts/ci-green-request.md" with { type: "text" };
+
+async function getHeadTag(api: CustomCommandAPI): Promise<string | undefined> {
+	const result = await api.exec("git", [
+		"for-each-ref",
+		"--points-at",
+		"HEAD",
+		"--sort=-version:refname",
+		"--format=%(refname:strip=2)",
+		"refs/tags",
+	]);
+
+	if (result.code !== 0 || result.killed) {
+		return undefined;
+	}
+
+	const tag = result.stdout
+		.split("\n")
+		.map(line => line.trim())
+		.find(Boolean);
+	return tag || undefined;
+}
+
+export class GreenCommand implements CustomCommand {
+	name = "green";
+	description = "Generate a prompt to iterate on CI failures until the branch is green";
+
+	constructor(private api: CustomCommandAPI) {}
+
+	async execute(_args: string[], _ctx: HookCommandContext): Promise<string> {
+		const headTag = await getHeadTag(this.api);
+		return renderPromptTemplate(ciGreenRequestTemplate, { headTag });
+	}
+}

package/src/extensibility/custom-commands/loader.ts

@@ -11,6 +11,7 @@ import { getAgentDir, getProjectDir, isEnoent, logger } from "@oh-my-pi/pi-utils
 import * as typebox from "@sinclair/typebox";
 import { getConfigDirs } from "../../config";
 import { execCommand } from "../../exec/exec";
+import { GreenCommand } from "./bundled/ci-green";
 import { ReviewCommand } from "./bundled/review";
 import type {
 	CustomCommand,
@@ -148,6 +149,12 @@ function loadBundledCommands(sharedApi: CustomCommandAPI): LoadedCustomCommand[]
 	const bundled: LoadedCustomCommand[] = [];
 
 	// Add bundled commands here
+	bundled.push({
+		path: "bundled:green",
+		resolvedPath: "bundled:green",
+		command: new GreenCommand(sharedApi),
+		source: "bundled",
+	});
 	bundled.push({
 		path: "bundled:review",
 		resolvedPath: "bundled:review",

package/src/extensibility/plugins/marketplace/fetcher.ts

@@ -125,48 +125,66 @@ export function parseMarketplaceCatalog(content: string, filePath: string): Mark
 	assertField(Array.isArray(obj.plugins), "plugins", filePath);
 
 	const plugins = obj.plugins as unknown[];
+	const validPlugins: unknown[] = [];
 	for (let i = 0; i < plugins.length; i++) {
-		const entry = plugins[i];
-		assertField(typeof entry === "object" && entry !== null && !Array.isArray(entry), `plugins[${i}]`, filePath);
-		const p = entry as Record<string, unknown>;
-		assertField(typeof p.name === "string" && isValidNameSegment(p.name), `plugins[${i}].name`, filePath);
-		// source can be a string path or a typed object (github/url/git-subdir/npm)
-		// all typed objects carry a "source" discriminant string field
-		assertField(
-			typeof p.source === "string" ||
-				(typeof p.source === "object" &&
-					p.source !== null &&
-					!Array.isArray(p.source) &&
-					typeof (p.source as Record<string, unknown>).source === "string"),
-			`plugins[${i}].source`,
-			filePath,
-		);
-		// String sources must be relative paths starting with "./"
-		if (typeof p.source === "string") {
-			assertField((p.source as string).startsWith("./"), `plugins[${i}].source (must start with "./")`, filePath);
-		}
-		// Validate required fields for typed source variants
-		if (typeof p.source === "object" && p.source !== null) {
-			const src = p.source as Record<string, unknown>;
-			const variant = src.source as string;
-			if (variant === "github") {
-				assertField(typeof src.repo === "string" && src.repo.length > 0, `plugins[${i}].source.repo`, filePath);
-			} else if (variant === "url" || variant === "git-subdir") {
-				assertField(typeof src.url === "string" && src.url.length > 0, `plugins[${i}].source.url`, filePath);
-				if (variant === "git-subdir") {
-					assertField(typeof src.path === "string" && src.path.length > 0, `plugins[${i}].source.path`, filePath);
+		try {
+			const entry = plugins[i];
+			assertField(typeof entry === "object" && entry !== null && !Array.isArray(entry), `plugins[${i}]`, filePath);
+			const p = entry as Record<string, unknown>;
+			assertField(typeof p.name === "string" && isValidNameSegment(p.name), `plugins[${i}].name`, filePath);
+			// source can be a string path or a typed object (github/url/git-subdir/npm)
+			// all typed objects carry a "source" discriminant string field
+			assertField(
+				typeof p.source === "string" ||
+					(typeof p.source === "object" &&
+						p.source !== null &&
+						!Array.isArray(p.source) &&
+						typeof (p.source as Record<string, unknown>).source === "string"),
+				`plugins[${i}].source`,
+				filePath,
+			);
+			// String sources must be relative paths starting with "./"
+			if (typeof p.source === "string") {
+				assertField((p.source as string).startsWith("./"), `plugins[${i}].source (must start with "./")`, filePath);
+			}
+			// Validate required fields for typed source variants
+			if (typeof p.source === "object" && p.source !== null) {
+				const src = p.source as Record<string, unknown>;
+				const variant = src.source as string;
+				if (variant === "github") {
+					assertField(typeof src.repo === "string" && src.repo.length > 0, `plugins[${i}].source.repo`, filePath);
+				} else if (variant === "url" || variant === "git-subdir") {
+					assertField(typeof src.url === "string" && src.url.length > 0, `plugins[${i}].source.url`, filePath);
+					if (variant === "git-subdir") {
+						assertField(
+							typeof src.path === "string" && src.path.length > 0,
+							`plugins[${i}].source.path`,
+							filePath,
+						);
+					}
+				} else if (variant === "npm") {
+					assertField(
+						typeof src.package === "string" && src.package.length > 0,
+						`plugins[${i}].source.package`,
+						filePath,
+					);
+				} else {
+					assertField(false, `plugins[${i}].source.source (unknown variant: "${variant}")`, filePath);
 				}
-			} else if (variant === "npm") {
-				assertField(
-					typeof src.package === "string" && src.package.length > 0,
-					`plugins[${i}].source.package`,
-					filePath,
-				);
-			} else {
-				assertField(false, `plugins[${i}].source.source (unknown variant: "${variant}")`, filePath);
 			}
+			validPlugins.push(entry);
+		} catch (err) {
+			// Warn and skip invalid plugin entries instead of failing the entire catalog.
+			// This lets the rest of the marketplace load even if one entry has a bad name/source.
+			const name =
+				typeof plugins[i] === "object" && plugins[i] !== null
+					? ((plugins[i] as Record<string, unknown>).name ?? `[${i}]`)
+					: `[${i}]`;
+			logger.warn(`Skipping invalid plugin ${name}: ${(err as Error).message}`);
 		}
 	}
+	// Replace the plugins array with only valid entries
+	obj.plugins = validPlugins;
 
 	// Extra fields are preserved — cast through unknown for type safety
 	return obj as unknown as MarketplaceCatalog;