pi-ui-extension 1.1.8 → 1.1.10

package/README.md

@@ -48,7 +48,18 @@ The bottom of the `SESSIONS` panel exposes four resource categories:
 - `Extensions`
 - `MCP`
 
-These shortcuts let you inspect the resources currently loaded by the project/Pi environment, making it easier to verify which agent instructions, skills, extensions, and MCP servers are actually available.
+These shortcuts let you inspect the resources discovered by the project/Pi environment. The MCP view distinguishes configured and registered servers from confirmed connections.
+
+#### MCP Status Center
+
+Click **MCP** in the sidebar to open a read-only status picker covering global and trusted-project MCP configuration, servers registered by extensions via `pi.registerMcpServer()`, and observations from `pi-mcp-adapter/status/v1`.
+
+- See configuration scope, project overrides, and enabled/disabled state (including native Pi `enabled: false`).
+- Connection health is only shown when an adapter explicitly reports it. **Configured, registered, and loaded do not mean connected.**
+- Commands, endpoints, headers, tokens, environment values, and raw errors are never displayed.
+- Tool usage now attributes native Pi `mcp__server__tool` calls to their MCP server, alongside existing gateway and `mcpScript` counts.
+
+Pi does not currently expose its complete native MCP connection state to ordinary UI extensions. For live connection diagnostics, reconnects, authentication, or configuration changes, use the active `/mcp` manager (built-in or provided by your MCP adapter).
 
 ### 4. CTX context inspection
 
@@ -154,7 +165,7 @@ Example configuration:
 To pin a specific version:
 
 ```bash
-pi install npm:pi-ui-extension@1.1.1
+pi install npm:pi-ui-extension@1.1.10
 ```
 
 or:
@@ -162,7 +173,7 @@ or:
 ```json
 {
   "packages": [
-    "npm:pi-ui-extension@1.1.1"
+    "npm:pi-ui-extension@1.1.10"
   ]
 }
 ```
@@ -190,15 +201,15 @@ Configuration form:
 Pin to a Git tag:
 
 ```bash
-pi install git:github.com/1993yihuan/pi-ui-extension@v1.1.1
+pi install git:github.com/1993yihuan/pi-ui-extension@v1.1.10
 ```
 
-### Temporary usage
+### Temporary local-source testing
 
-To load the package for a single Pi launch without modifying `settings.json`:
+To try a local checkout without changing `settings.json`, run from the repository root. Disable automatic extension discovery to avoid loading a previously installed copy of `pi-ui-extension` twice:
 
 ```bash
-pi -e npm:pi-ui-extension
+pi --no-extensions -e builtin:mcp -e ./extensions/index.ts --tui-mode fullscreen
 ```
 
 ### Project-local installation
@@ -337,7 +348,7 @@ Pi's extension entry point is declared explicitly in `package.json`:
 
 ## CI / Release
 
-Every push to `main` and every pull request runs:
+Every push to `main` and every pull request runs on **both Node.js 22.19.0 and 24**:
 
 ```text
 npm ci
@@ -357,6 +368,7 @@ A `v*` tag triggers the release workflow:
 
 ```text
 Checkout
+→ validate release tag format and main ancestry
 → Node.js 24
 → npm ci
 → npm run check
@@ -364,6 +376,7 @@ Checkout
 → npm pack --dry-run
 → npm Trusted Publishing (OIDC)
 → npm publish
+→ verify npm Registry visibility (with retries)
 → GitHub Release
 ```
 
@@ -382,7 +395,7 @@ npm publishing uses GitHub Actions OIDC Trusted Publishing, so no long-lived `NP
 
 - Pi Coding Agent
 - Node.js `>= 22.19.0` (use a Node version supported by your Pi installation)
-- Development and CI currently use Node.js 24
+- CI validates Node.js 22.19.0 and 24; releases use Node.js 24
 
 ## License
 

package/README.zh-CN.md

@@ -48,7 +48,18 @@ Sidebar 支持鼠标交互、滚轮滚动和终端尺寸变化。终端高度不
 - `Extensions`
 - `MCP`
 
-点击后可以直接查看当前项目 / 当前 Pi 环境中已加载的相关资源，便于快速确认 Agent 当前实际使用了哪些上下文、Skill、Extension 和 MCP Server。
+点击后可以查看当前项目 / Pi 环境发现的相关资源。其中 MCP 状态中心会区分“已配置 / 已注册”和“已确认连接”，避免把配置存在误认为连接成功。
+
+#### MCP 状态中心
+
+点击 Sidebar 中的 **MCP** 按钮可打开只读状态中心，查看全局和可信项目配置的 MCP Server、扩展通过 `pi.registerMcpServer()` 注册的服务器，以及 `pi-mcp-adapter/status/v1` 提供的运行时观察结果。
+
+- 显示服务器来源、启用/禁用状态与配置覆盖情况；项目级 `enabled: false` 会正确覆盖全局配置。
+- 仅当 Adapter 明确报告连接状态时显示 Connected、Connecting、Failed 等状态；**已配置、已注册或已加载不代表已连接**。
+- 不展示命令、URL、环境变量、请求头、Token 或原始错误内容。
+- 工具调用统计支持 Pi 原生 `mcp__server__tool` 格式，继续兼容既有 MCP Gateway / `mcpScript` 统计。
+
+Pi 目前没有向普通 UI 扩展公开完整的原生 MCP 实时连接状态。查看连接错误、重新连接、登录或启停服务器，请使用当前生效的 `/mcp` 管理界面（Pi 内置或由第三方 MCP Adapter 提供）；本状态中心不执行连接或配置修改。
 
 ### 4. CTX 上下文观察
 
@@ -154,7 +165,7 @@ Pi 会安装 package，并将声明写入个人配置：
 如果希望固定版本：
 
 ```bash
-pi install npm:pi-ui-extension@1.1.1
+pi install npm:pi-ui-extension@1.1.10
 ```
 
 或者：
@@ -162,7 +173,7 @@ pi install npm:pi-ui-extension@1.1.1
 ```json
 {
   "packages": [
-    "npm:pi-ui-extension@1.1.1"
+    "npm:pi-ui-extension@1.1.10"
   ]
 }
 ```
@@ -190,15 +201,15 @@ pi install git:github.com/1993yihuan/pi-ui-extension
 固定到 Git tag：
 
 ```bash
-pi install git:github.com/1993yihuan/pi-ui-extension@v1.1.1
+pi install git:github.com/1993yihuan/pi-ui-extension@v1.1.10
 ```
 
-### 临时试用
+### 临时加载本地源码
 
-如果只想在一次 Pi 启动中测试，不修改 `settings.json`：
+如果只想在一次 Pi 启动中测试本地源码，不修改 `settings.json`，请在仓库根目录运行。禁用自动扩展发现可以避免与已经安装的 `pi-ui-extension` 重复加载：
 
 ```bash
-pi -e npm:pi-ui-extension
+pi --no-extensions -e builtin:mcp -e ./extensions/index.ts --tui-mode fullscreen
 ```
 
 ### 项目级安装
@@ -337,7 +348,7 @@ Pi 的扩展入口在 `package.json` 中显式声明：
 
 ## CI / Release
 
-提交到 `main` 或创建 PR 时，GitHub Actions 会自动执行：
+提交到 `main` 或创建 PR 时，GitHub Actions 会分别在 **Node.js 22.19.0 和 24** 上执行：
 
 ```text
 npm ci
@@ -357,6 +368,7 @@ git push --tags
 
 ```text
 Checkout
+→ 校验版本标签格式、确认提交位于 main 历史
 → Node.js 24
 → npm ci
 → npm run check
@@ -364,6 +376,7 @@ Checkout
 → npm pack --dry-run
 → npm Trusted Publishing (OIDC)
 → npm publish
+→ 重试检查 npm Registry 已可查询新版本
 → GitHub Release
 ```
 
@@ -382,7 +395,7 @@ npm 发布使用 GitHub Actions OIDC Trusted Publishing，不需要在 GitHub Re
 
 - Pi Coding Agent
 - Node.js `>= 22.19.0`（建议使用当前 Pi 支持的 Node 版本）
-- 开发与 CI 当前使用 Node.js 24
+- CI 覆盖 Node.js 22.19.0 和 24；发布工作流使用 Node.js 24
 
 ## License
 

package/extensions/index.ts

@@ -13,7 +13,7 @@ import { installContextEstimates } from "./ctx/data.ts";
 import { createActivityTracker, type ActivityTracker } from "./ctx/activity.ts";
 import { installFooter, type FooterController } from "./footer/index.ts";
 import { isFabricFullCodeMode } from "./fabric-detection.ts";
-import { mcpResourceEntriesFromConfig, mcpResourceEntriesFromStatus, mergeMcpResourceEntries } from "./mcp/resources.ts";
+import { adapterMcpServers, buildMcpStatusSnapshot, describeMcpStatus, type McpStatusSnapshot } from "./mcp/status-center.ts";
 import {
   createDefaultSidebarPanels,
   SESSION_PANEL_ID,
@@ -103,6 +103,49 @@ function showResourceDialog(
   });
 }
 
+/** Read-only MCP status picker; only safe metadata is displayed. */
+export function showMcpStatusDialog(
+  ctx: { ui: { select(title: string, options: string[]): Promise<string | undefined>; editor(title: string, prefill?: string): Promise<string | undefined>; notify(message: string, level: "info" | "warning"): void } },
+  snapshot: McpStatusSnapshot,
+): void {
+  const rows = snapshot.servers.map((server) => ({
+    name: server.name,
+    description: describeMcpStatus(server),
+    details: [
+      `Server: ${server.name}`,
+      `Source: ${server.source}`,
+      `Enabled: ${server.enabled ? "yes" : "no"}`,
+      `Observed by adapter: ${server.loaded ? "yes" : "no"}`,
+      `Status: ${describeMcpStatus(server)}`,
+      "",
+      "Only an adapter's explicit connection state establishes connected/failed.",
+      "Pi native connection health is not exposed to UI extensions.",
+      "Use Pi's built-in /mcp manager for live connection details.",
+    ].join("\n"),
+  }));
+  const warnings = snapshot.warnings.map((warning) => ({
+    name: "⚠ Configuration warning",
+    description: warning,
+    details: `${warning}\nCheck your MCP configuration with Pi's built-in /mcp manager.`,
+  }));
+  const all = [...rows, ...warnings];
+  if (all.length === 0) {
+    ctx.ui.notify("No MCP servers found. Use /mcp to configure servers.", "info");
+    return;
+  }
+  const choices = resourceDialogOptions(all);
+  const enabledCount = snapshot.servers.filter((server) => server.enabled).length;
+  void ctx.ui.select(
+    `MCP Status · ${enabledCount} enabled / ${snapshot.servers.length} total · ↵ details`,
+    choices,
+  ).then((choice) => {
+    if (!choice) return;
+    const index = choices.indexOf(choice);
+    const item = all[index];
+    if (item) void ctx.ui.editor(`${item.name} · MCP (read-only)`, item.details).then(() => {});
+  });
+}
+
 /** Load Agents.md contexts, Skills, and Extensions as display rows. */
 export async function loadResourceEntries(
   pi: ExtensionAPI,
@@ -185,9 +228,11 @@ async function clearOtherSessions(
 export default async function piUiExtension(pi: ExtensionAPI): Promise<void> {
   const toolView = await installToolViewController(pi);
   let mcpResources: readonly ResourceEntry[] = [];
-  let liveMcpResources: readonly ResourceEntry[] = [];
-  const currentMcpResources = (cwd: string, trusted: boolean): readonly ResourceEntry[] =>
-    mergeMcpResourceEntries(mcpResourceEntriesFromConfig(getAgentDir(), cwd, trusted), liveMcpResources);
+  let liveMcpServers: NonNullable<ReturnType<typeof adapterMcpServers>> = [];
+  let registeredServers: unknown = [];
+  let mcpCwd = process.cwd();
+  let mcpTrusted = false;
+  let mcpStatus: McpStatusSnapshot = { servers: [], warnings: [] };
   let toolViewMode: ToolViewMode | undefined;
   let footer: FooterController | undefined;
   let sidebar: SidebarController | undefined;
@@ -221,12 +266,24 @@ export default async function piUiExtension(pi: ExtensionAPI): Promise<void> {
   };
   let switchRequested = false;
   const getMcpServerNames = () => mcpResources.map((server) => server.name);
-  const unsubscribeMcpStatus = pi.events.on("pi-mcp-adapter/status/v1", (value) => {
-    liveMcpResources = mcpResourceEntriesFromStatus(value);
-    mcpResources = mergeMcpResourceEntries(mcpResources, liveMcpResources);
+  const updateMcpStatus = (): void => {
+    mcpStatus = buildMcpStatusSnapshot(getAgentDir(), mcpCwd, mcpTrusted, registeredServers, liveMcpServers);
+    mcpResources = mcpStatus.servers
+      .filter((server) => server.enabled)
+      .map((server) => ({ name: server.name, description: describeMcpStatus(server) }));
     const branch = getCurrentBranch?.();
     if (branch) toolUsage?.resetSession(branch, getMcpServerNames(), { preserveExchange: true });
     sidebar?.refresh();
+  };
+  const unsubscribeMcpStatus = pi.events.on("pi-mcp-adapter/status/v1", (value) => {
+    const observation = adapterMcpServers(value);
+    if (!observation) return;
+    liveMcpServers = observation;
+    updateMcpStatus();
+  });
+  pi.on("mcp_servers_change", (event) => {
+    registeredServers = event.servers;
+    updateMcpStatus();
   });
 
   pi.registerCommand(SESSION_RENAME_COMMAND, {
@@ -456,7 +513,10 @@ export default async function piUiExtension(pi: ExtensionAPI): Promise<void> {
     // Pi resets extension UI before starting/reloading a session. Do not call
     // stale controllers from the previous runtime after that reset.
     clearControllers();
-    mcpResources = currentMcpResources(ctx.cwd, ctx.isProjectTrusted());
+    mcpCwd = ctx.cwd;
+    mcpTrusted = ctx.isProjectTrusted();
+    registeredServers = typeof pi.getMcpServers === "function" ? pi.getMcpServers() : [];
+    updateMcpStatus();
     toolViewMode = toolView.getMode();
     getCurrentBranch = () => ctx.sessionManager.getBranch();
     const branch = ctx.sessionManager.getBranch();
@@ -534,7 +594,12 @@ export default async function piUiExtension(pi: ExtensionAPI): Promise<void> {
               ctx.ui.notify("Wait for the current run to finish before opening resources", "warning");
               return;
             }
-            void loadResourceEntries(pi, ctx.cwd, button === "mcp" ? currentMcpResources(ctx.cwd, ctx.isProjectTrusted()) : mcpResources, ctx.isProjectTrusted(), button)
+            if (button === "mcp") {
+              updateMcpStatus();
+              showMcpStatusDialog(ctx, mcpStatus);
+              return;
+            }
+            void loadResourceEntries(pi, ctx.cwd, mcpResources, ctx.isProjectTrusted(), button)
               .then((rows) => {
                 if (!rows || rows.length === 0) {
                   ctx.ui.notify("No resources of this kind loaded", "info");
@@ -568,6 +633,7 @@ export default async function piUiExtension(pi: ExtensionAPI): Promise<void> {
   pi.on("session_shutdown", () => {
     unsubscribeToolViewMode();
     unsubscribeMcpStatus();
+    liveMcpServers = [];
 
     // The sidebar replaces the fullscreen TUI layout root directly, so Pi
     // cannot tear it down on our behalf during session replacement. Dispose

package/extensions/mcp/integration.test.ts

@@ -11,6 +11,7 @@ test("entry wires early/late MCP status into restored and live usage without dou
   const handlers = new Map<string, any[]>(), bus = new Map<string, any>();
   const listeners = new Set<any>();
   let branch: any[] = [], footer: any;
+  let registrations: any[] = [{ name: "native_mcp", config: { command: "not-executed" }, extensionPath: "/extension.ts" }];
   const tui: any = {
     [Symbol.for("@earendil-works/pi-tui/viewport")]: true,
     terminal: { columns: 240, rows: 100 }, layoutRoot: { render: () => [], invalidate() {} }, inputListeners: listeners,
@@ -21,6 +22,7 @@ test("entry wires early/late MCP status into restored and live usage without dou
   const pi: any = {
     registerTool() {}, registerCommand() {}, registerShortcut() {},
     getCommands: () => [], getActiveTools: () => [], getAllTools: () => [], getThinkingLevel: () => "off",
+    getMcpServers: () => registrations,
     on(name: string, fn: any) { handlers.set(name, [...(handlers.get(name) ?? []), fn]); },
     events: { on(name: string, fn: any) { bus.set(name, fn); return () => bus.delete(name); } },
   };
@@ -41,6 +43,12 @@ test("entry wires early/late MCP status into restored and live usage without dou
     await emit("session_start");
     assert.match(output(), /early\s+0\/1/);
     await emit("before_agent_start", { systemPromptOptions: {} });
+    branch.push({ type: "message", message: { role: "toolResult", toolName: "mcp__native_mcp__ping", details: {} } });
+    await emit("tool_execution_end", { toolCallId: "native-1", toolName: "mcp__native_mcp__ping", isError: false, result: { details: {} } });
+    assert.match(output(), /native_mcp\s+1\/1/);
+    registrations = [];
+    await emit("mcp_servers_change", { servers: [] });
+    assert.doesNotMatch(output(), /native_mcp\s+1\/1/);
     branch.push(saved("late"));
     await emit("tool_execution_end", { toolCallId: "call-1", toolName: "mcpScript", isError: false, result: { details: details("late") } });
     assert.doesNotMatch(output(), /late\s+1\/1/);

package/extensions/mcp/resources.ts

@@ -1,5 +1,4 @@
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
+import { adapterMcpServers, configuredMcpServers } from "./status-center.ts";
 
 export type McpResourceEntry = {
   readonly name: string;
@@ -7,26 +6,9 @@ export type McpResourceEntry = {
 };
 
 export function mcpResourceEntriesFromConfig(agentDir: string, cwd: string, trusted: boolean): readonly McpResourceEntry[] {
-  const paths = [join(agentDir, "mcp.json")];
-  if (trusted) paths.push(join(cwd, ".pi", "mcp.json"));
-  const rows = new Map<string, McpResourceEntry>();
-  for (const path of paths) {
-    try {
-      const config: unknown = JSON.parse(readFileSync(path, "utf8"));
-      if (!config || typeof config !== "object" || Array.isArray(config)) continue;
-      const servers = (config as { mcpServers?: unknown }).mcpServers;
-      if (!servers || typeof servers !== "object" || Array.isArray(servers)) continue;
-      for (const [name, value] of Object.entries(servers)) {
-        if (!name.trim() || !value || typeof value !== "object" || Array.isArray(value)) continue;
-        if ((value as { disabled?: unknown }).disabled === true) {
-          rows.delete(name);
-          continue;
-        }
-        rows.set(name, { name, description: "Configured MCP server (connection not verified)" });
-      }
-    } catch { /* Missing or invalid configuration is not fatal. */ }
-  }
-  return [...rows.values()];
+  return configuredMcpServers(agentDir, cwd, trusted).servers
+    .filter((server) => server.enabled)
+    .map(({ name }) => ({ name, description: "Configured MCP server (connection not verified)" }));
 }
 
 export function mergeMcpResourceEntries(configured: readonly McpResourceEntry[], live: readonly McpResourceEntry[]): readonly McpResourceEntry[] {
@@ -35,29 +17,9 @@ export function mergeMcpResourceEntries(configured: readonly McpResourceEntry[],
   return [...rows.values()];
 }
 
-type McpStatusServer = {
-  readonly name?: unknown;
-  readonly disabled?: unknown;
-};
-
 /** Convert the adapter's read-only status snapshot into configured, enabled MCP rows. */
 export function mcpResourceEntriesFromStatus(value: unknown): readonly McpResourceEntry[] {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return [];
-  const snapshot = value as { version?: unknown; servers?: unknown };
-  if (snapshot.version !== 1 || !Array.isArray(snapshot.servers)) return [];
-
-  const seen = new Set<string>();
-  const rows: McpResourceEntry[] = [];
-  for (const rawServer of snapshot.servers) {
-    if (typeof rawServer !== "object" || rawServer === null || Array.isArray(rawServer)) continue;
-    const server = rawServer as McpStatusServer;
-    const name = typeof server.name === "string" ? server.name.trim() : "";
-    if (!name || server.disabled === true || seen.has(name)) continue;
-    seen.add(name);
-    rows.push({
-      name,
-      description: "MCP server loaded in the current Pi session",
-    });
-  }
-  return rows;
+  return (adapterMcpServers(value) ?? [])
+    .filter((server) => server.enabled)
+    .map(({ name }) => ({ name, description: "MCP server loaded in the current Pi session" }));
 }

package/extensions/mcp/status-center.test.ts

@@ -0,0 +1,147 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { showMcpStatusDialog } from "../index.ts";
+import {
+  adapterMcpServers, buildMcpStatusSnapshot, configuredMcpServers,
+  describeMcpStatus, registeredMcpServers,
+} from "./status-center.ts";
+
+function withConfigs<Result>(run: (agent: string, project: string) => Result): Result {
+  const root = mkdtempSync(join(tmpdir(), "pi-mcp-status-"));
+  const agent = join(root, "agent");
+  const project = join(root, "project");
+  mkdirSync(agent);
+  mkdirSync(join(project, ".pi"), { recursive: true });
+  try { return run(agent, project); }
+  finally { rmSync(root, { recursive: true, force: true }); }
+}
+
+test("native Pi enabled:false and trusted project overrides win without leaking config", () => {
+  withConfigs((agent, project) => {
+    writeFileSync(join(agent, "mcp.json"), JSON.stringify({ mcpServers: {
+      docs: { url: "https://private.example/token-123", headers: { Authorization: "Bearer secret" } },
+      blocked: { command: "super-secret-executable", enabled: false },
+      reenable: { command: "secret-command", enabled: false },
+    } }));
+    writeFileSync(join(project, ".pi", "mcp.json"), JSON.stringify({ mcpServers: {
+      docs: { enabled: false },
+      reenable: { enabled: true, exposure: "direct" },
+      local: { command: "private-key-path" },
+    } }));
+
+    assert.deepEqual(configuredMcpServers(agent, project, false).servers.map((s) => [s.name, s.enabled]), [
+      ["docs", true], ["blocked", false], ["reenable", false],
+    ]);
+    const snapshot = buildMcpStatusSnapshot(agent, project, true, []);
+    assert.deepEqual(snapshot.servers.map((s) => [s.name, s.source, s.enabled]), [
+      ["docs", "project override", false],
+      ["blocked", "global", false],
+      ["reenable", "project override", true],
+      ["local", "project", true],
+    ]);
+    assert.doesNotMatch(JSON.stringify(snapshot), /token-123|secret|private-key-path/);
+    assert.match(describeMcpStatus(snapshot.servers[0]!), /Disabled/);
+  });
+});
+
+test("extension registrations are not mistaken for confirmed connections", () => {
+  withConfigs((agent, project) => {
+    const registered = [
+      { name: "extension_mcp", extensionPath: "/sensitive/path", config: { url: "https://secret.invalid" } },
+      { name: "disabled_ext", config: { command: "secret", enabled: false } },
+      { name: "\u001b[31munsafe", config: { command: "secret" } },
+    ];
+    assert.deepEqual(registeredMcpServers(registered).map((s) => s.name), ["extension_mcp", "disabled_ext"]);
+    const snapshot = buildMcpStatusSnapshot(agent, project, true, registered);
+    assert.deepEqual(snapshot.servers.map((s) => [s.name, s.source, s.connection]), [
+      ["extension_mcp", "extension", "unknown"],
+      ["disabled_ext", "extension", "unknown"],
+    ]);
+    assert.match(describeMcpStatus(snapshot.servers[0]!), /Registered.*unverified/);
+    assert.doesNotMatch(JSON.stringify(snapshot), /sensitive|secret|unsafe/);
+  });
+});
+
+test("adapter v1 reports loading separately from explicit health and ignores disabled entries", () => {
+  withConfigs((agent, project) => {
+    writeFileSync(join(agent, "mcp.json"), JSON.stringify({ mcpServers: {
+      docs: { command: "secret" },
+      blocked: { enabled: false, command: "secret" },
+    } }));
+    const observed = adapterMcpServers({ version: 1, servers: [
+      { name: "docs" },
+      { name: "logged_in", state: "connected", error: "secret" },
+      { name: "auth", status: "needs-auth", headers: { Authorization: "secret" } },
+      { name: "blocked", state: "connected" },
+      { name: "not_running", enabled: false, state: "connected" },
+      { name: "logged_in", state: "connected" },
+      { name: "\u001b[33muntrusted", state: "connected" },
+    ] });
+    assert.equal(observed?.length, 5);
+    const snapshot = buildMcpStatusSnapshot(agent, project, true, [], observed);
+    assert.deepEqual(snapshot.servers.map((s) => [s.name, s.enabled, s.loaded, s.connection]), [
+      ["docs", true, true, "unknown"],
+      ["blocked", false, false, "unknown"],
+      ["logged_in", true, true, "connected"],
+      ["auth", true, true, "needs-auth"],
+      ["not_running", false, false, "unknown"],
+    ]);
+    assert.match(describeMcpStatus(snapshot.servers[0]!), /Loaded.*unverified/);
+    assert.match(describeMcpStatus(snapshot.servers[2]!), /Connected.*adapter reported/);
+    assert.doesNotMatch(JSON.stringify(snapshot), /secret|untrusted/);
+    assert.deepEqual(
+      buildMcpStatusSnapshot(agent, project, true, [], []).servers.map((s) => s.name),
+      ["docs", "blocked"],
+      "a replacement adapter snapshot must not retain removed servers",
+    );
+  });
+});
+
+test("malformed adapter snapshots and invalid config files fail safely", () => {
+  assert.equal(adapterMcpServers({ version: 2, servers: [] }), undefined);
+  assert.equal(adapterMcpServers({ version: 1, servers: "bad" }), undefined);
+  assert.deepEqual(adapterMcpServers({ version: 1, servers: [{ name: "ok", state: "bogus" }] }), [
+    { name: "ok", enabled: true, state: "unknown" },
+  ]);
+  withConfigs((agent, project) => {
+    writeFileSync(join(agent, "mcp.json"), '{"mcpServers":{"api":{"headers":{"Authorization":"secret"}}');
+    const snapshot = buildMcpStatusSnapshot(agent, project, false, []);
+    assert.deepEqual(snapshot.servers, []);
+    assert.deepEqual(snapshot.warnings, ["Invalid global MCP configuration"]);
+    assert.doesNotMatch(JSON.stringify(snapshot), /secret/);
+  });
+});
+
+test("MCP status center opens a safe read-only detail without leaking secrets", async () => {
+  const snapshot = withConfigs((agent, project) => {
+    writeFileSync(join(agent, "mcp.json"), JSON.stringify({ mcpServers: {
+      docs: { command: "token-very-secret" },
+      blocked: { url: "https://private.invalid", enabled: false },
+    } }));
+    return buildMcpStatusSnapshot(agent, project, true, [], adapterMcpServers({
+      version: 1, servers: [{ name: "docs", state: "connected", token: "token-very-secret" }],
+    }));
+  });
+  const selected: string[] = [];
+  const details: string[] = [];
+  showMcpStatusDialog({ ui: {
+    select(title: string, choices: string[]) {
+      selected.push(title, ...choices);
+      return Promise.resolve(choices[0]);
+    },
+    editor(title: string, content = "") {
+      details.push(title, content);
+      return Promise.resolve(undefined);
+    },
+    notify() {},
+  } }, snapshot);
+  await new Promise<void>((resolve) => setImmediate(resolve));
+  assert.match(selected.join("\n"), /MCP Status.*1 enabled \/ 2 total/);
+  assert.match(selected.join("\n"), /docs.*Connected/);
+  assert.match(selected.join("\n"), /blocked.*Disabled/);
+  assert.match(details.join("\n"), /Use Pi's built-in \/mcp/);
+  assert.doesNotMatch(JSON.stringify({ selected, details }), /token-very-secret|private.invalid/);
+});

package/extensions/mcp/status-center.ts

@@ -0,0 +1,178 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+export type McpConnectionState =
+  | "unknown" | "connecting" | "connected" | "disconnected" | "needs-auth" | "failed";
+export type McpStatusSource = "global" | "project" | "project override" | "extension" | "adapter";
+export type McpServerStatus = {
+  readonly name: string;
+  readonly source: McpStatusSource;
+  readonly enabled: boolean;
+  readonly loaded: boolean;
+  /** Only an explicit runtime observation can establish connection state. */
+  readonly connection: McpConnectionState;
+};
+export type McpStatusSnapshot = {
+  readonly servers: readonly McpServerStatus[];
+  readonly warnings: readonly string[];
+};
+
+type ConfigServer = { name: string; source: McpStatusSource; enabled: boolean };
+type ParsedConfig = { servers: Map<string, Record<string, unknown>> };
+type RuntimeServer = { name: string; enabled: boolean; state: McpConnectionState };
+
+function record(value: unknown): Record<string, unknown> | undefined {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown> : undefined;
+}
+
+/** Pi MCP names are deliberately constrained; never render arbitrary terminal input from events. */
+function serverName(value: unknown): string | undefined {
+  return typeof value === "string" && /^[a-zA-Z0-9_-]+$/.test(value) ? value : undefined;
+}
+
+function isEnabled(config: Record<string, unknown>): boolean {
+  // Pi uses enabled:false. Disabled:true is accepted for older adapter configs.
+  return config.enabled !== false && config.disabled !== true;
+}
+
+function readConfig(path: string, warnings: string[], scope: "global" | "project"): ParsedConfig {
+  let raw: string;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "ENOENT") warnings.push(`Cannot read ${scope} MCP configuration`);
+    return { servers: new Map() };
+  }
+  try {
+    const config = record(JSON.parse(raw));
+    if (!config) throw new Error("invalid configuration shape");
+    const servers = config.mcpServers === undefined ? {} : record(config.mcpServers);
+    if (!servers) throw new Error("invalid server map");
+    const entries = new Map<string, Record<string, unknown>>();
+    for (const [name, value] of Object.entries(servers)) {
+      const server = record(value);
+      if (!serverName(name) || !server) {
+        warnings.push(`Invalid server entry in ${scope} MCP configuration`);
+        continue;
+      }
+      entries.set(name, server);
+    }
+    return { servers: entries };
+  } catch {
+    // Never include JSON contents, URLs, command lines, headers or parser excerpts.
+    warnings.push(`Invalid ${scope} MCP configuration`);
+    return { servers: new Map() };
+  }
+}
+
+/** Read native Pi global/project MCP configuration without touching credentials or transports. */
+export function configuredMcpServers(
+  agentDir: string, cwd: string, trusted: boolean,
+): { readonly servers: readonly ConfigServer[]; readonly warnings: readonly string[] } {
+  const warnings: string[] = [];
+  const global = readConfig(join(agentDir, "mcp.json"), warnings, "global");
+  const entries = new Map<string, ConfigServer>();
+  for (const [name, value] of global.servers) {
+    entries.set(name, { name, source: "global", enabled: isEnabled(value) });
+  }
+  if (trusted) {
+    const project = readConfig(join(cwd, ".pi", "mcp.json"), warnings, "project");
+    for (const [name, value] of project.servers) {
+      const overridesGlobal = entries.has(name) &&
+        !("command" in value || "url" in value || "type" in value);
+      const previous = entries.get(name);
+      // Pi permits project-only enabled/exposure overrides of global servers.
+      entries.set(name, {
+        name,
+        source: overridesGlobal ? "project override" : "project",
+        enabled: overridesGlobal && value.enabled === undefined && value.disabled === undefined
+          ? previous!.enabled : isEnabled(value),
+      });
+    }
+  }
+  return { servers: [...entries.values()], warnings };
+}
+
+/** Extract extension-registered MCP names. Registration does not prove connection. */
+export function registeredMcpServers(value: unknown): readonly RuntimeServer[] {
+  if (!Array.isArray(value)) return [];
+  const rows = new Map<string, RuntimeServer>();
+  for (const item of value) {
+    const server = record(item);
+    const name = serverName(server?.name);
+    const config = record(server?.config);
+    if (name && config) rows.set(name, { name, enabled: isEnabled(config), state: "unknown" });
+  }
+  return [...rows.values()];
+}
+
+/** Adapter v1 snapshots are observations, not an authoritative native Pi state API. */
+export function adapterMcpServers(snapshot: unknown): readonly RuntimeServer[] | undefined {
+  const value = record(snapshot);
+  if (value?.version !== 1 || !Array.isArray(value.servers)) return undefined;
+  const rows = new Map<string, RuntimeServer>();
+  for (const entry of value.servers) {
+    const server = record(entry);
+    const name = serverName(server?.name);
+    if (!name) continue;
+    const explicit = server?.state ?? server?.status;
+    const state: McpConnectionState =
+      explicit === "connected" || explicit === "connecting" ||
+      explicit === "disconnected" || explicit === "needs-auth" || explicit === "failed"
+        ? explicit
+        : server?.connected === true ? "connected"
+          : server?.connected === false ? "disconnected" : "unknown";
+    rows.set(name, { name, enabled: isEnabled(server!), state });
+  }
+  return [...rows.values()];
+}
+
+export function buildMcpStatusSnapshot(
+  agentDir: string,
+  cwd: string,
+  trusted: boolean,
+  registered: unknown,
+  adapter: readonly RuntimeServer[] = [],
+): McpStatusSnapshot {
+  const config = configuredMcpServers(agentDir, cwd, trusted);
+  const rows = new Map<string, McpServerStatus>();
+  for (const server of config.servers) {
+    rows.set(server.name, { ...server, loaded: false, connection: "unknown" });
+  }
+  for (const server of registeredMcpServers(registered)) {
+    if (!rows.has(server.name)) {
+      rows.set(server.name, { name: server.name, source: "extension", enabled: server.enabled, loaded: false, connection: "unknown" });
+    }
+  }
+  for (const server of adapter) {
+    const configured = rows.get(server.name);
+    if (configured) {
+      // An explicit project disable must not be overwritten by an adapter's stale snapshot.
+      rows.set(server.name, {
+        ...configured,
+        loaded: server.enabled && configured.enabled,
+        connection: server.enabled && configured.enabled ? server.state : "unknown",
+      });
+    } else {
+      rows.set(server.name, {
+        name: server.name, source: "adapter", enabled: server.enabled,
+        loaded: server.enabled, connection: server.enabled ? server.state : "unknown",
+      });
+    }
+  }
+  return { servers: [...rows.values()], warnings: config.warnings };
+}
+
+export function describeMcpStatus(server: McpServerStatus): string {
+  const state = !server.enabled ? "Disabled"
+    : server.connection === "connected" ? "Connected (adapter reported)"
+      : server.connection === "connecting" ? "Connecting (adapter reported)"
+        : server.connection === "disconnected" ? "Disconnected (adapter reported)"
+          : server.connection === "needs-auth" ? "Sign-in required (adapter reported)"
+            : server.connection === "failed" ? "Failed (adapter reported)"
+              : server.loaded ? "Loaded (connection unverified)"
+                : server.source === "extension" ? "Registered (connection unverified)"
+                  : "Configured (connection unverified)";
+  return `${state} · ${server.source}`;
+}

package/extensions/tool-view/usage.test.ts

@@ -80,6 +80,29 @@ test("adds the MCP server for proxy calls without hiding the gateway count", ()
   ]);
 });
 
+test("attributes Pi native MCP tools to known servers, including sanitized names", () => {
+  const tracker = createToolUsageTracker([], () => ["docs", "chrome-devtools"]);
+  tracker.startExchange();
+  tracker.record(ended("mcp__docs__search"));
+  tracker.record(ended("mcp__chrome_devtools__open_page"));
+  assert.deepEqual(tracker.getSnapshot().counts.filter((s) => s.kind === "mcp"), [
+    { name: "chrome-devtools", kind: "mcp", exchange: 1, session: 1 },
+    { name: "docs", kind: "mcp", exchange: 1, session: 1 },
+  ]);
+  const restored = [{ type: "message", message: { role: "toolResult", toolName: "mcp__docs__search", details: {} } }];
+  tracker.resetSession(restored, ["docs"]);
+  assert.deepEqual(tracker.getSnapshot().counts.filter((s) => s.kind === "mcp"), [
+    { name: "docs", kind: "mcp", exchange: 0, session: 1 },
+  ]);
+});
+
+test("does not guess an MCP server from ambiguous normalized names", () => {
+  const tracker = createToolUsageTracker([], () => ["team-core", "team_core"]);
+  tracker.startExchange();
+  tracker.record(ended("mcp__team_core__search"));
+  assert.deepEqual(tracker.getSnapshot().counts.filter((s) => s.kind === "mcp"), []);
+});
+
 test("counts each MCP call made by mcpScript", () => {
   const tracker = createToolUsageTracker([], () => ["codebase-memory-mcp", "context-mode"]);
   tracker.startExchange();

package/extensions/tool-view/usage.ts

@@ -109,6 +109,16 @@ function resolveScriptServer(path: string, knownServers: readonly string[]): str
   return candidates.size === 1 ? [...candidates][0] : undefined;
 }
 
+/** Pi native MCP tools use mcp__<sanitized-server>__<tool>. Never guess on collisions. */
+function nativeMcpServer(toolName: string, knownServers: readonly string[]): string | undefined {
+  if (!toolName.startsWith("mcp__")) return undefined;
+  const matches = knownServers.filter((server) => {
+    const normalized = server.replace(/[^A-Za-z0-9_]/g, "_");
+    return toolName.startsWith(`mcp__${normalized}__`);
+  });
+  return matches.length === 1 ? matches[0] : undefined;
+}
+
 function scriptServers(result: unknown, knownServers: readonly string[]): string[] {
   const details = asRecord(asRecord(result)?.details);
   if (details?.mode !== "script" || !Array.isArray(details.calls)) return [];
@@ -145,6 +155,9 @@ function parseUsage(toolName: string, result: unknown, knownServers: readonly st
   const contextServer = contextModeServer(topLevelName);
   if (contextServer) return { topLevelName, mcpServers: [contextServer] };
 
+  const nativeServer = nativeMcpServer(topLevelName, knownServers);
+  if (nativeServer) return { topLevelName, mcpServers: [nativeServer] };
+
   if (topLevelName === "mcpScript") {
     return { topLevelName, mcpServers: scriptServers(result, knownServers) };
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ui-extension",
-  "version": "1.1.8",
+  "version": "1.1.10",
   "type": "module",
   "description": "Pi terminal UI extension with session management, context inspection, Tool/MCP usage tracking, sidebar panels, and a compact footer",
   "keywords": [
@@ -37,8 +37,8 @@
     }
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "1.0.2",
-    "@earendil-works/pi-tui": "1.0.2",
+    "@earendil-works/pi-coding-agent": "1.1.0",
+    "@earendil-works/pi-tui": "1.1.0",
     "@types/node": "^26.6.4",
     "tsx": "^4.20.6",
     "typescript": "^7.0.2"