@oh-my-pi/pi-coding-agent 16.2.6 → 16.2.7

package/src/main.ts

@@ -140,7 +140,7 @@ const HOST_DEFAULTED_SETTING_PATHS: SettingPath[] = [
 	"advisor.subagents",
 	"advisor.syncBacklog",
 	"advisor.immuneTurns",
-	"serviceTierAdvisor",
+	"tier.advisor",
 ];
 
 const RPC_BACKGROUND_DEFAULTED_SETTING_PATHS: SettingPath[] = [

package/src/mcp/config-writer.ts

@@ -227,3 +227,124 @@ export async function setServerDisabled(filePath: string, name: string, disabled
 
 	await writeMCPConfigFile(filePath, updated);
 }
+
+/**
+ * Read the user-level force-enable list (allowlist that overrides a
+ * non-writable source config's `enabled: false`).
+ */
+export async function readEnabledServers(filePath: string): Promise<string[]> {
+	const config = await readMCPConfigFile(filePath);
+	return Array.isArray(config.enabledServers) ? config.enabledServers : [];
+}
+
+/**
+ * Add or remove a server name from the user-level force-enable list.
+ * The list overrides a discovered server's `enabled: false` flag but does
+ * NOT override the `disabledServers` denylist.
+ */
+export async function setServerForceEnabled(filePath: string, name: string, force: boolean): Promise<void> {
+	const config = await readMCPConfigFile(filePath);
+	const current = new Set(config.enabledServers ?? []);
+
+	if (force) {
+		current.add(name);
+	} else {
+		current.delete(name);
+	}
+
+	const updated: MCPConfigFile = {
+		...config,
+		enabledServers: current.size > 0 ? Array.from(current).sort() : undefined,
+	};
+
+	if (!updated.enabledServers) {
+		delete updated.enabledServers;
+	}
+
+	await writeMCPConfigFile(filePath, updated);
+}
+
+/** Paths and target state for toggling one MCP server across known config files. */
+export interface SetMcpServerEnabledOptions {
+	userPath: string;
+	projectPath: string;
+	/**
+	 * Absolute path to the loaded row's source mcp.json. Provide ONLY for
+	 * formats this codebase owns (native `.omp/mcp.json` and `mcp-json`
+	 * `mcp.json`/`.mcp.json`). Tool-owned configs (opencode.json, claude.json,
+	 * settings.json …) MUST be omitted; we never mutate another tool's file.
+	 */
+	sourcePath?: string;
+	name: string;
+	enabled: boolean;
+}
+
+/**
+ * Flip a server's enabled/disabled state regardless of where it lives.
+ *
+ * Resolution order, mirroring `/mcp enable` / `/mcp disable` plus the dashboard
+ * fix for non-writable source configs:
+ *
+ * - Server found in `sourcePath` (writable) → write `enabled` on that entry.
+ * - Else server in project mcp.json → write `enabled` there.
+ * - Else server in user mcp.json → write `enabled` there.
+ * - Else (server defined in a tool-owned source like opencode.json, OR a
+ *   purely discovered server):
+ *   - Disable → add to the user-level `disabledServers` denylist.
+ *   - Enable → add to the user-level `enabledServers` allowlist so the
+ *     dashboard / runtime override the non-writable source's
+ *     `enabled: false` flag.
+ *
+ * Cleanup invariants — on every call:
+ * - Re-enable clears any stale denylist entry so a server disabled via
+ *   `/mcp disable` and re-enabled here doesn't stay suppressed.
+ * - Disable clears any stale allowlist entry so re-disabling a
+ *   force-enabled server actually takes effect.
+ */
+export async function setMcpServerEnabled(options: SetMcpServerEnabledOptions): Promise<void> {
+	const { userPath, projectPath, sourcePath, name, enabled } = options;
+	const candidatePaths = [...new Set([sourcePath, projectPath, userPath].filter(path => path !== undefined))];
+	let updatedInConfig = false;
+
+	for (const filePath of candidatePaths) {
+		const config = await readMCPConfigFile(filePath);
+		const server = config.mcpServers?.[name];
+		if (server === undefined) continue;
+
+		await updateMCPServer(filePath, name, { ...server, enabled });
+		updatedInConfig = true;
+		break;
+	}
+
+	if (enabled) {
+		// Either we just wrote `enabled: true` on a writable source, or the
+		// server lives in a non-writable source whose `enabled: false` flag we
+		// need to override via the user allowlist. Either way the denylist
+		// entry (if any) must clear so the row becomes active.
+		const denied = await readDisabledServers(userPath);
+		if (denied.includes(name)) {
+			await setServerDisabled(userPath, name, false);
+		}
+
+		const forced = await readEnabledServers(userPath);
+		const isForced = forced.includes(name);
+		if (!updatedInConfig && !isForced) {
+			await setServerForceEnabled(userPath, name, true);
+		} else if (updatedInConfig && isForced) {
+			// Writable source now carries `enabled: true`; the override is
+			// redundant. Drop it so the user's allowlist stays tidy.
+			await setServerForceEnabled(userPath, name, false);
+		}
+		return;
+	}
+
+	// Disable path. Clear any force-enable override regardless of source so the
+	// disable actually sticks.
+	const forced = await readEnabledServers(userPath);
+	if (forced.includes(name)) {
+		await setServerForceEnabled(userPath, name, false);
+	}
+	if (!updatedInConfig) {
+		await setServerDisabled(userPath, name, true);
+	}
+}

package/src/mcp/config.ts

@@ -9,7 +9,7 @@ import { mcpCapability } from "../capability/mcp";
 import type { SourceMeta } from "../capability/types";
 import type { MCPServer } from "../discovery";
 import { loadCapability } from "../discovery";
-import { readDisabledServers } from "./config-writer";
+import { readDisabledServers, readEnabledServers } from "./config-writer";
 import type { MCPServerConfig } from "./types";
 
 /** Options for loading MCP configs */
@@ -105,16 +105,20 @@ export async function loadAllMCPConfigs(cwd: string, options?: LoadMCPConfigsOpt
 		? result.items
 		: result.items.filter(server => server._source.level !== "project");
 
-	// Load user-level disabled servers list
-	const disabledServers = new Set(await readDisabledServers(getMCPConfigPath("user", cwd)));
+	// Load user-level disable/force-enable lists. The denylist always wins; the
+	// allowlist overrides a non-writable source config's `enabled: false`.
+	const userPath = getMCPConfigPath("user", cwd);
+	const [disabledServers, forcedEnabled] = await Promise.all([
+		readDisabledServers(userPath).then(list => new Set(list)),
+		readEnabledServers(userPath).then(list => new Set(list)),
+	]);
 	// Convert to legacy format and preserve source metadata
 	let configs: Record<string, MCPServerConfig> = {};
 	let sources: Record<string, SourceMeta> = {};
 	for (const server of servers) {
 		const config = convertToLegacyConfig(server);
-		if (config.enabled === false || disabledServers.has(server.name)) {
-			continue;
-		}
+		if (disabledServers.has(server.name)) continue;
+		if (config.enabled === false && !forcedEnabled.has(server.name)) continue;
 		configs[server.name] = config;
 		sources[server.name] = server._source;
 	}

package/src/mcp/types.ts

@@ -111,7 +111,10 @@ export const MCP_CONFIG_SCHEMA_URL =
 export interface MCPConfigFile {
 	$schema?: string;
 	mcpServers?: Record<string, MCPServerConfig>;
+	/** Names to hide regardless of any source `enabled` flag. Highest precedence. */
 	disabledServers?: string[];
+	/** Names to force-enable when a non-writable source reports `enabled: false`. */
+	enabledServers?: string[];
 }
 
 // =============================================================================

package/src/modes/components/extensions/extension-dashboard.ts

@@ -24,7 +24,9 @@ import {
 	truncateToWidth,
 	visibleWidth,
 } from "@oh-my-pi/pi-tui";
+import { getMCPConfigPath, logger } from "@oh-my-pi/pi-utils";
 import { Settings } from "../../../config/settings";
+import { setMcpServerEnabled } from "../../../mcp/config-writer";
 import { getTabBarTheme } from "../../../modes/shared";
 import { theme } from "../../../modes/theme/theme";
 import { matchesAppInterrupt } from "../../../modes/utils/keybinding-matchers";
@@ -263,6 +265,14 @@ export class ExtensionDashboard implements Component {
 		const sm = this.settings ?? Settings.instance;
 		if (!sm) return;
 
+		// MCP toggles route through the canonical denylist in
+		// `~/.omp/agent/mcp.json` so `/mcp list`, the MCP runtime, and this
+		// dashboard agree on every server's enabled state (issue #3827).
+		if (extensionId.startsWith("mcp:")) {
+			void this.#toggleMcpExtension(extensionId, enabled, sm);
+			return;
+		}
+
 		const disabled = ((sm.get("disabledExtensions") as string[]) ?? []).slice();
 		if (enabled) {
 			const index = disabled.indexOf(extensionId);
@@ -281,6 +291,42 @@ export class ExtensionDashboard implements Component {
 		void this.#refreshFromState();
 	}
 
+	async #toggleMcpExtension(extensionId: string, enabled: boolean, sm: Settings): Promise<void> {
+		const name = extensionId.slice("mcp:".length);
+		try {
+			await setMcpServerEnabled({
+				userPath: getMCPConfigPath("user", this.cwd),
+				projectPath: getMCPConfigPath("project", this.cwd),
+				sourcePath: this.#writableMcpSourcePath(extensionId),
+				name,
+				enabled,
+			});
+		} catch (error) {
+			logger.warn("Failed to persist MCP toggle", { name, enabled, error: String(error) });
+		}
+
+		// Reconcile `settings.disabledExtensions` with the canonical mcp.json
+		// state so a legacy `mcp:<name>` flag from before this routing change
+		// doesn't keep the server marked disabled after the user re-enables it
+		// via the UI.
+		const stored = ((sm.get("disabledExtensions") as string[]) ?? []).slice();
+		const had = stored.indexOf(extensionId);
+		if (enabled && had !== -1) {
+			stored.splice(had, 1);
+			sm.set("disabledExtensions", stored);
+			this.#applyDisabledExtensions(stored);
+		}
+
+		await this.#refreshFromState();
+	}
+
+	#writableMcpSourcePath(extensionId: string): string | undefined {
+		const extension = this.#state.extensions.find(ext => ext.id === extensionId);
+		if (!extension) return undefined;
+		if (extension.source.provider !== "native" && extension.source.provider !== "mcp-json") return undefined;
+		return extension.path;
+	}
+
 	async #refreshFromState(): Promise<void> {
 		const refreshToken = ++this.#refreshToken;
 		// Remember the current tab so it survives the re-sort.

package/src/modes/components/extensions/state-manager.ts

@@ -4,7 +4,7 @@
  */
 import * as path from "node:path";
 import { fuzzyMatch } from "@oh-my-pi/pi-tui";
-import { logger } from "@oh-my-pi/pi-utils";
+import { getMCPConfigPath, logger } from "@oh-my-pi/pi-utils";
 import type { ContextFile } from "../../../capability/context-file";
 import type { ExtensionModule } from "../../../capability/extension-module";
 import type { Hook } from "../../../capability/hook";
@@ -22,6 +22,7 @@ import {
 	isProviderEnabled,
 	loadCapability,
 } from "../../../discovery";
+import { readDisabledServers, readEnabledServers } from "../../../mcp/config-writer";
 import type {
 	DashboardState,
 	Extension,
@@ -141,12 +142,32 @@ export async function loadAllExtensions(cwd?: string, disabledIds?: string[]): P
 		logger.warn("Failed to load extension-modules capability", { error: String(error) });
 	}
 
-	// Load MCP servers
+	// Load MCP servers. The dashboard mirrors `/mcp list` (issue #3827) by
+	// honoring the same disable signals: the dashboard-private settings list,
+	// the per-server `enabled: false` flag, and the user-level `disabledServers`
+	// denylist that `/mcp disable` writes through `setServerDisabled`. The
+	// user-level `enabledServers` allowlist overrides a non-writable source's
+	// `enabled: false` (e.g. opencode.json) but never the denylist.
 	try {
+		const userMcpPath = cwd ? getMCPConfigPath("user", cwd) : undefined;
+		const [mcpDisabledNames, mcpForcedEnabled] = await Promise.all([
+			userMcpPath
+				? readDisabledServers(userMcpPath)
+						.then(list => new Set(list))
+						.catch(() => new Set<string>())
+				: Promise.resolve(new Set<string>()),
+			userMcpPath
+				? readEnabledServers(userMcpPath)
+						.then(list => new Set(list))
+						.catch(() => new Set<string>())
+				: Promise.resolve(new Set<string>()),
+		]);
 		const mcps = await loadCapability<MCPServer>("mcps", loadOpts);
 		for (const server of mcps.all) {
 			const id = makeExtensionId("mcp", server.name);
-			const isDisabled = disabledExtensions.has(id);
+			const forced = mcpForcedEnabled.has(server.name);
+			const sourceSaysDisabled = server.enabled === false && !forced;
+			const isDisabled = mcpDisabledNames.has(server.name) || disabledExtensions.has(id) || sourceSaysDisabled;
 			const isShadowed = (server as { _shadowed?: boolean })._shadowed;
 			const providerEnabled = isProviderEnabled(server._source.provider);
 

package/src/modes/controllers/event-controller.ts

@@ -890,6 +890,13 @@ export class EventController {
 	}
 
 	async #handleToolExecutionEnd(event: Extract<AgentSessionEvent, { type: "tool_execution_end" }>): Promise<void> {
+		// A transient overlay (auto-compaction / auto-retry / handoff) that ran
+		// between this tool's start and end could have detached the working
+		// loader. `tool_execution_update` already reconciles this so the spinner
+		// reappears mid-tool; mirror it here so subagent (`task`) completions —
+		// which only fire `tool_execution_end`, never `_update` — do not leave
+		// the UI looking idle while the session keeps streaming (#3857).
+		this.#ensureWorkingLoaderWhileStreaming();
 		if (event.toolName === "read") {
 			if (this.#inlineReadToolImages(event.toolCallId, event.result)) {
 				const component = this.ctx.pendingTools.get(event.toolCallId);

package/src/modes/utils/transcript-render-helpers.ts

@@ -99,9 +99,9 @@ export function buildFileMentionBlock(files: FileMentionMessage["files"], indent
 	const block = new TranscriptBlock();
 	for (const file of files) {
 		let suffix: string;
-		if (file.skippedReason === "tooLarge") {
+		if (file.skippedReason === "tooLarge" || file.skippedReason === "binary") {
 			const size = typeof file.byteSize === "number" ? formatBytes(file.byteSize) : "unknown size";
-			suffix = `(skipped: ${size})`;
+			suffix = file.skippedReason === "binary" ? `(skipped: binary, ${size})` : `(skipped: ${size})`;
 		} else {
 			suffix = file.image
 				? "(image)"

package/src/sdk.ts

@@ -42,6 +42,7 @@ import {
 	resolveModelRoleValue,
 } from "./config/model-resolver";
 import { loadPromptTemplates as loadPromptTemplatesInternal, type PromptTemplate } from "./config/prompt-templates";
+import { buildServiceTierByFamily } from "./config/service-tier";
 import { Settings, type SkillsSettings } from "./config/settings";
 import { CursorExecHandlers } from "./cursor";
 import "./discovery";
@@ -1537,7 +1538,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			getModelString: () => (hasExplicitModel && model ? formatModelString(model) : undefined),
 			getActiveModelString,
 			getActiveModel: () => agent?.state.model ?? model,
-			getServiceTier: () => session?.serviceTier,
+			getServiceTierByFamily: () => session?.serviceTierByFamily,
 			getImageAttachments: () => session?.getImageAttachments() ?? [],
 			getPlanModeState: () => session?.getPlanModeState(),
 			getPlanReferencePath: () => session?.getPlanReferencePath() ?? "local://PLAN.md",
@@ -2525,13 +2526,13 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		const openaiWebsocketSetting = settings.get("providers.openaiWebsockets") ?? "off";
 		const preferOpenAICodexWebsockets =
 			openaiWebsocketSetting === "on" ? true : openaiWebsocketSetting === "off" ? false : undefined;
-		const serviceTierSetting = settings.get("serviceTier");
-
-		const initialServiceTier = hasServiceTierEntry
-			? existingSession.serviceTier
-			: serviceTierSetting === "none"
-				? undefined
-				: serviceTierSetting;
+		const initialServiceTierByFamily = hasServiceTierEntry
+			? (existingSession.serviceTier ?? {})
+			: buildServiceTierByFamily(
+					settings.get("tier.openai"),
+					settings.get("tier.anthropic"),
+					settings.get("tier.google"),
+				);
 
 		// One-shot launch-latency marker: fired the first time the loop dispatches
 		// a chat request to the provider transport. See onFirstChatDispatch.
@@ -2579,7 +2580,6 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			minP: settings.get("minP") >= 0 ? settings.get("minP") : undefined,
 			presencePenalty: settings.get("presencePenalty") >= 0 ? settings.get("presencePenalty") : undefined,
 			repetitionPenalty: settings.get("repetitionPenalty") >= 0 ? settings.get("repetitionPenalty") : undefined,
-			serviceTier: initialServiceTier,
 			hideThinkingSummary: settings.get("omitThinking"),
 			kimiApiFormat: settings.get("providers.kimiApiFormat") ?? "anthropic",
 			preferWebsockets: preferOpenAICodexWebsockets,
@@ -2639,8 +2639,8 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				// classification persists its concrete effort once a real user turn runs.
 				sessionManager.appendThinkingLevelChange(effectiveThinkingLevel);
 			}
-			if (initialServiceTier) {
-				sessionManager.appendServiceTierChange(initialServiceTier);
+			if (Object.keys(initialServiceTierByFamily).length > 0) {
+				sessionManager.appendServiceTierChange(initialServiceTierByFamily);
 			}
 		}
 
@@ -2691,6 +2691,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			agent,
 			pruneToolDescriptions: inlineToolDescriptors,
 			thinkingLevel: autoThinking ? AUTO_THINKING : effectiveThinkingLevel,
+			serviceTierByFamily: initialServiceTierByFamily,
 			sessionManager,
 			settings,
 			autoApprove: options.autoApprove,