@pi-harness/pi-harness 0.1.13 → 0.1.14

package/packages/core/src/plugins/tab-manager.ts

@@ -1,11 +1,17 @@
-import { readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { mkdir, rename, rm, writeFile } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
 import type { Context } from "@deepseek-ai/cordis";
 import { Type } from "@earendil-works/pi-ai";
 import { defineTool, type AgentToolResult } from "@earendil-works/pi-coding-agent";
+import { readBoundedTextFile } from "../bounded-file.js";
+import { EmptyConfig } from "../config.js";
 
 const storageFile = "session-tabs.json";
 const maxTabs = 24;
+const maxStateFileBytes = 1024 * 1024;
+const lockRetryMs = 25;
+const lockTimeoutMs = 10_000;
 type Tab = { id: string; label: string; sessionPath: string; pinned: boolean; updatedAt: string };
 type TabState = { tabs: Tab[]; activeId: string | null };
 
@@ -14,119 +20,211 @@ function emptyState(): TabState {
 }
 
 async function readState(path: string): Promise<TabState> {
+  let source: string;
   try {
-    const parsed: unknown = JSON.parse(await readFile(path, "utf8"));
-    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return emptyState();
-    const value = parsed as { tabs?: unknown; activeId?: unknown };
-    const tabs = Array.isArray(value.tabs)
-      ? value.tabs.filter(
-          (tab): tab is Tab =>
-            tab !== null &&
-            typeof tab === "object" &&
-            typeof (tab as { id?: unknown }).id === "string" &&
-            typeof (tab as { label?: unknown }).label === "string" &&
-            typeof (tab as { sessionPath?: unknown }).sessionPath === "string" &&
-            typeof (tab as { pinned?: unknown }).pinned === "boolean" &&
-            typeof (tab as { updatedAt?: unknown }).updatedAt === "string",
-        )
-      : [];
-    return { tabs: tabs.slice(0, maxTabs), activeId: typeof value.activeId === "string" ? value.activeId : null };
-  } catch {
-    return emptyState();
+    source = await readBoundedTextFile(path, maxStateFileBytes, "Session tab store");
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return emptyState();
+    throw error;
   }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(source) as unknown;
+  } catch (error) {
+    throw new Error("Session tab store contains invalid JSON", { cause: error });
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("Session tab store has an unsupported format");
+  const value = parsed as { tabs?: unknown; activeId?: unknown };
+  if (!Array.isArray(value.tabs) || (value.activeId !== null && typeof value.activeId !== "string"))
+    throw new Error("Session tab store has an unsupported format");
+  if (value.tabs.length > maxTabs) throw new Error(`Session tab store exceeds the ${maxTabs}-tab limit`);
+  const tabs: Tab[] = [];
+  for (const candidate of value.tabs) {
+    if (candidate === null || typeof candidate !== "object" || Array.isArray(candidate)) throw new Error("Session tab store contains invalid tabs");
+    const tab = candidate as Record<string, unknown>;
+    if (
+      typeof tab.id !== "string" ||
+      tab.id.length === 0 ||
+      tab.id.length > 512 ||
+      typeof tab.label !== "string" ||
+      tab.label.trim().length === 0 ||
+      tab.label.length > 120 ||
+      typeof tab.sessionPath !== "string" ||
+      tab.sessionPath.length === 0 ||
+      tab.sessionPath.length > 4_096 ||
+      typeof tab.pinned !== "boolean" ||
+      typeof tab.updatedAt !== "string" ||
+      !Number.isFinite(Date.parse(tab.updatedAt))
+    )
+      throw new Error("Session tab store contains invalid tabs");
+    tabs.push(tab as Tab);
+  }
+  if (new Set(tabs.map((tab) => tab.id)).size !== tabs.length || new Set(tabs.map((tab) => tab.sessionPath)).size !== tabs.length)
+    throw new Error("Session tab store contains duplicate tabs");
+  if (typeof value.activeId === "string" && !tabs.some((tab) => tab.id === value.activeId)) throw new Error("Session tab store contains an invalid active tab");
+  return { tabs, activeId: value.activeId };
 }
 
 async function persist(path: string, state: TabState): Promise<void> {
-  await writeFile(path, JSON.stringify(state, null, 2) + "\n", "utf8");
+  await mkdir(dirname(path), { recursive: true });
+  const temporary = join(dirname(path), `.${basename(path)}.${randomUUID()}.tmp`);
+  let renamed = false;
+  try {
+    await writeFile(temporary, JSON.stringify(state, null, 2) + "\n", { encoding: "utf8", mode: 0o600, flag: "wx" });
+    await rename(temporary, path);
+    renamed = true;
+  } finally {
+    if (!renamed) await rm(temporary, { force: true }).catch(() => undefined);
+  }
+}
+
+async function acquireTabLock(lockPath: string): Promise<() => Promise<void>> {
+  await mkdir(dirname(lockPath), { recursive: true });
+  const deadline = Date.now() + lockTimeoutMs;
+  while (true) {
+    try {
+      await mkdir(lockPath);
+      return async () => {
+        await rm(lockPath, { recursive: true, force: true });
+      };
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "EEXIST" || Date.now() >= deadline)
+        throw new Error("Timed out waiting for session tab store lock", { cause: error });
+      await new Promise<void>((resolve) => setTimeout(resolve, lockRetryMs));
+    }
+  }
 }
 
 export default {
   name: "pi-tab-manager",
   inject: ["piHarnessLaunch", "piSession", "piPluginUi", "piTools"],
+  Config: EmptyConfig,
   async apply(context: Context) {
     const path = join(context.piHarnessLaunch.agentDir, storageFile);
-    const state = await readState(path);
+    let state = await readState(path);
+    let mutationQueue = Promise.resolve();
     let writes = 0;
     const activeSession = (): { id: string; sessionPath: string } => ({
       id: context.piSession.manager.getSessionId(),
       sessionPath: context.piSession.manager.getSessionFile() ?? join(context.piHarnessLaunch.agentDir, `${context.piSession.manager.getSessionId()}.jsonl`),
     });
-    const upsert = (id: string, sessionPath: string, label: string | undefined, pinned: boolean): Tab => {
+    const upsert = (current: TabState, id: string, sessionPath: string, label: string | undefined, pinned: boolean): Tab => {
       const now = new Date().toISOString();
-      const existing = state.tabs.find((tab) => tab.id === id || tab.sessionPath === sessionPath);
+      const existing = current.tabs.find((tab) => tab.id === id || tab.sessionPath === sessionPath);
       if (existing !== undefined) {
         existing.label = label?.trim() || existing.label;
         existing.pinned = pinned;
         existing.updatedAt = now;
-        state.activeId = existing.id;
+        current.activeId = existing.id;
         return existing;
       }
-      if (state.tabs.length >= maxTabs) throw new Error(`A maximum of ${maxTabs} session tabs is supported`);
+      if (current.tabs.length >= maxTabs) throw new Error(`A maximum of ${maxTabs} session tabs is supported`);
       const tab = { id, label: label?.trim() || id, sessionPath, pinned, updatedAt: now };
-      state.tabs = [tab, ...state.tabs];
-      state.activeId = tab.id;
+      current.tabs = [tab, ...current.tabs];
+      current.activeId = tab.id;
       return tab;
     };
+    const mutate = async <T>(operation: (current: TabState) => T): Promise<T> => {
+      let result: T | undefined;
+      const run = async (): Promise<void> => {
+        const release = await acquireTabLock(`${path}.lock`);
+        try {
+          const current = await readState(path);
+          result = operation(current);
+          await persist(path, current);
+          state = current;
+          writes += 1;
+        } finally {
+          await release();
+        }
+      };
+      mutationQueue = mutationQueue.catch(() => undefined).then(run);
+      await mutationQueue;
+      return result as T;
+    };
     const unregisterTool = context.piTools.register(
       defineTool({
         name: "session_tab_manage",
         label: "Session tabs",
         description: "Pin, rename, activate, remove, or list lightweight session tabs without deleting session files.",
         promptSnippet: "organize open Pi sessions as named tabs",
-        parameters: Type.Object({
-          action: Type.Union(["pin", "unpin", "rename", "activate", "remove", "list"]),
-          sessionPath: Type.Optional(Type.String()),
-          label: Type.Optional(Type.String()),
-        }),
+        parameters: Type.Object(
+          {
+            action: Type.Union(["pin", "unpin", "rename", "activate", "remove", "list"]),
+            sessionPath: Type.Optional(Type.String()),
+            label: Type.Optional(Type.String()),
+          },
+          { additionalProperties: false },
+        ),
+        executionMode: "sequential",
         async execute(_toolCallId, params): Promise<AgentToolResult<TabState | Tab>> {
           const active = activeSession();
           const targetPath = params.sessionPath?.trim() || active.sessionPath;
-          const target = state.tabs.find((tab) => tab.sessionPath === targetPath);
-          if (params.action === "list") return { content: [{ type: "text", text: `${state.tabs.length} session tab(s).` }], details: state };
+          if (params.label !== undefined && params.label.trim().length > 120) throw new Error("Tab label must be 1 to 120 characters");
+          if (params.action === "list") {
+            state = await readState(path);
+            return { content: [{ type: "text", text: `${state.tabs.length} session tab(s).` }], details: state };
+          }
           if (params.action === "activate") {
-            if (target === undefined) throw new Error("Session tab not found");
-            state.activeId = target.id;
-            target.updatedAt = new Date().toISOString();
-            await persist(path, state);
-            writes += 1;
-            return { content: [{ type: "text", text: `Active session tab: ${target.label}` }], details: state };
+            const label = await mutate((current) => {
+              const target = current.tabs.find((tab) => tab.sessionPath === targetPath);
+              if (target === undefined) throw new Error("Session tab not found");
+              current.activeId = target.id;
+              target.updatedAt = new Date().toISOString();
+              return target.label;
+            });
+            return { content: [{ type: "text", text: `Active session tab: ${label}` }], details: state };
           }
           if (params.action === "remove") {
-            if (target === undefined) throw new Error("Session tab not found");
-            state.tabs = state.tabs.filter((tab) => tab !== target);
-            state.activeId = state.tabs[0]?.id ?? null;
+            await mutate((current) => {
+              const target = current.tabs.find((tab) => tab.sessionPath === targetPath);
+              if (target === undefined) throw new Error("Session tab not found");
+              current.tabs = current.tabs.filter((tab) => tab !== target);
+              current.activeId = current.tabs[0]?.id ?? null;
+            });
           } else if (params.action === "rename") {
-            if (target === undefined) throw new Error("Session tab not found");
             const label = params.label?.trim() ?? "";
             if (label.length === 0 || label.length > 120) throw new Error("Tab label must be 1 to 120 characters");
-            target.label = label;
-            target.updatedAt = new Date().toISOString();
-            state.activeId = target.id;
+            await mutate((current) => {
+              const target = current.tabs.find((tab) => tab.sessionPath === targetPath);
+              if (target === undefined) throw new Error("Session tab not found");
+              target.label = label;
+              target.updatedAt = new Date().toISOString();
+              current.activeId = target.id;
+            });
           } else if (params.action === "pin") {
-            const tab = upsert(active.id, targetPath, params.label, params.action === "pin");
-            await persist(path, state);
-            writes += 1;
+            const tab = await mutate((current) => upsert(current, active.id, targetPath, params.label, true));
             return { content: [{ type: "text", text: `Pinned session tab: ${tab.label}` }], details: tab };
           } else {
-            if (target === undefined) throw new Error("Session tab not found");
-            target.pinned = false;
-            target.updatedAt = new Date().toISOString();
-            state.activeId = target.id;
+            await mutate((current) => {
+              const target = current.tabs.find((tab) => tab.sessionPath === targetPath);
+              if (target === undefined) throw new Error("Session tab not found");
+              target.pinned = false;
+              target.updatedAt = new Date().toISOString();
+              current.activeId = target.id;
+            });
           }
-          await persist(path, state);
-          writes += 1;
           return { content: [{ type: "text", text: `Session tabs: ${state.tabs.length}.` }], details: state };
         },
       }),
     );
-    const disposePanel = context.piPluginUi.register({
-      id: "tab-manager-panel",
-      pluginId: "@pi-harness/core/plugins/tab-manager",
-      title: "Session Tabs",
-      description: "管理命名会话标签；移除标签不会删除会话文件。",
-      icon: "▣",
-      read: () => ({ activeId: state.activeId, tabs: state.tabs, writes }),
-    });
+    let disposePanel: () => void;
+    try {
+      disposePanel = context.piPluginUi.register({
+        id: "tab-manager-panel",
+        pluginId: "@pi-harness/core/plugins/tab-manager",
+        title: "Session Tabs",
+        description: "管理命名会话标签；移除标签不会删除会话文件。",
+        icon: "▣",
+        read: async () => {
+          state = await readState(path);
+          return { activeId: state.activeId, tabs: state.tabs, writes };
+        },
+      });
+    } catch (error) {
+      unregisterTool();
+      throw error;
+    }
     context.effect(() => () => {
       unregisterTool();
       disposePanel();

package/packages/core/src/plugins/taskboard.ts

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { mkdir } from "node:fs/promises";
+import { lstat, mkdir, open } from "node:fs/promises";
 import { DatabaseSync } from "node:sqlite";
 import { basename, dirname, resolve } from "node:path";
 import type { Context } from "@deepseek-ai/cordis";
@@ -127,6 +127,23 @@ function withTransaction<T>(database: DatabaseSync, operation: () => T): T {
   }
 }
 
+async function prepareDatabasePath(filePath: string): Promise<{ dev: number; ino: number }> {
+  try {
+    const handle = await open(filePath, "wx", 0o600);
+    try {
+      const metadata = await handle.stat();
+      return { dev: metadata.dev, ino: metadata.ino };
+    } finally {
+      await handle.close();
+    }
+  } catch (error) {
+    if (!(typeof error === "object" && error !== null && "code" in error && (error as { code?: unknown }).code === "EEXIST")) throw error;
+    const metadata = await lstat(filePath);
+    if (!metadata.isFile()) throw new Error("Taskboard database must be a regular file and cannot be a symbolic link", { cause: error });
+    return { dev: metadata.dev, ino: metadata.ino };
+  }
+}
+
 export default {
   name: "pi-taskboard",
   inject: ["piHarnessLaunch", "piPluginUi", "piTools"],
@@ -139,25 +156,29 @@ export default {
 
     const withDatabase = async <T>(operation: (database: DatabaseSync) => T): Promise<T> => {
       await mkdir(dirname(filePath), { recursive: true });
+      const expected = await prepareDatabasePath(filePath);
       const database = new DatabaseSync(filePath);
-      database.exec(`
-        CREATE TABLE IF NOT EXISTS tasks (
-          id TEXT PRIMARY KEY,
-          task_key TEXT NOT NULL UNIQUE,
-          workspace TEXT NOT NULL,
-          title TEXT NOT NULL,
-          description TEXT NOT NULL DEFAULT '',
-          status TEXT NOT NULL CHECK (status IN ('backlog','todo','in_progress','in_review','blocked','canceled','done')),
-          priority TEXT NOT NULL CHECK (priority IN ('low','medium','high','urgent')),
-          due_date TEXT,
-          created_at TEXT NOT NULL,
-          updated_at TEXT NOT NULL,
-          version INTEGER NOT NULL
-        );
-        CREATE INDEX IF NOT EXISTS tasks_workspace_updated ON tasks(workspace, updated_at DESC);
-        CREATE INDEX IF NOT EXISTS tasks_workspace_status ON tasks(workspace, status);
-      `);
       try {
+        const actual = await lstat(filePath);
+        if (!actual.isFile() || actual.dev !== expected.dev || actual.ino !== expected.ino)
+          throw new Error("Taskboard database must remain the same regular file while opening");
+        database.exec(`
+          CREATE TABLE IF NOT EXISTS tasks (
+            id TEXT PRIMARY KEY,
+            task_key TEXT NOT NULL UNIQUE,
+            workspace TEXT NOT NULL,
+            title TEXT NOT NULL,
+            description TEXT NOT NULL DEFAULT '',
+            status TEXT NOT NULL CHECK (status IN ('backlog','todo','in_progress','in_review','blocked','canceled','done')),
+            priority TEXT NOT NULL CHECK (priority IN ('low','medium','high','urgent')),
+            due_date TEXT,
+            created_at TEXT NOT NULL,
+            updated_at TEXT NOT NULL,
+            version INTEGER NOT NULL
+          );
+          CREATE INDEX IF NOT EXISTS tasks_workspace_updated ON tasks(workspace, updated_at DESC);
+          CREATE INDEX IF NOT EXISTS tasks_workspace_status ON tasks(workspace, status);
+        `);
         return operation(database);
       } finally {
         database.close();
@@ -184,12 +205,16 @@ export default {
       label: "Create taskboard task",
       description: "Create a local project task with a stable readable key and an explicit priority.",
       promptSnippet: "create a taskboard task for this workspace",
-      parameters: Type.Object({
-        title: Type.String(),
-        description: Type.Optional(Type.String()),
-        priority: Type.Optional(Type.Union([Type.Literal("low"), Type.Literal("medium"), Type.Literal("high"), Type.Literal("urgent")])),
-        dueDate: Type.Optional(Type.String()),
-      }),
+      parameters: Type.Object(
+        {
+          title: Type.String(),
+          description: Type.Optional(Type.String()),
+          priority: Type.Optional(Type.Union([Type.Literal("low"), Type.Literal("medium"), Type.Literal("high"), Type.Literal("urgent")])),
+          dueDate: Type.Optional(Type.String()),
+        },
+        { additionalProperties: false },
+      ),
+      executionMode: "sequential",
       async execute(_toolCallId, params): Promise<AgentToolResult<Task>> {
         const title = normalizeText(params.title, "Taskboard title", maxTitleLength);
         const description = normalizeDescription(params.description);
@@ -244,13 +269,17 @@ export default {
       label: "List taskboard tasks",
       description: "List bounded local tasks for this workspace, optionally filtered by status or text.",
       promptSnippet: "list taskboard tasks for this workspace",
-      parameters: Type.Object({
-        status: Type.Optional(
-          Type.Union(statuses.map((status) => Type.Literal(status)) as [ReturnType<typeof Type.Literal>, ...ReturnType<typeof Type.Literal>[]]),
-        ),
-        query: Type.Optional(Type.String()),
-        limit: Type.Optional(Type.Number()),
-      }),
+      parameters: Type.Object(
+        {
+          status: Type.Optional(
+            Type.Union(statuses.map((status) => Type.Literal(status)) as [ReturnType<typeof Type.Literal>, ...ReturnType<typeof Type.Literal>[]]),
+          ),
+          query: Type.Optional(Type.String()),
+          limit: Type.Optional(Type.Number()),
+        },
+        { additionalProperties: false },
+      ),
+      executionMode: "sequential",
       async execute(_toolCallId, params): Promise<AgentToolResult<TaskReport>> {
         const query = params.query === undefined ? undefined : normalizeText(params.query, "Taskboard query", maxQueryLength);
         const limit = Math.max(1, Math.min(maxTasksPerList, Math.trunc(params.limit ?? 20)));
@@ -291,22 +320,26 @@ export default {
       label: "Update taskboard task",
       description: "Update task details or move a task through the agent-owned workflow; completion requires taskboard_accept.",
       promptSnippet: "update a taskboard task without bypassing completion review",
-      parameters: Type.Object({
-        key: Type.String(),
-        title: Type.Optional(Type.String()),
-        description: Type.Optional(Type.String()),
-        status: Type.Optional(
-          Type.Union(
-            statuses.filter((status) => status !== "done").map((status) => Type.Literal(status)) as [
-              ReturnType<typeof Type.Literal>,
-              ...ReturnType<typeof Type.Literal>[],
-            ],
+      parameters: Type.Object(
+        {
+          key: Type.String(),
+          title: Type.Optional(Type.String()),
+          description: Type.Optional(Type.String()),
+          status: Type.Optional(
+            Type.Union(
+              statuses.filter((status) => status !== "done").map((status) => Type.Literal(status)) as [
+                ReturnType<typeof Type.Literal>,
+                ...ReturnType<typeof Type.Literal>[],
+              ],
+            ),
           ),
-        ),
-        priority: Type.Optional(Type.Union([Type.Literal("low"), Type.Literal("medium"), Type.Literal("high"), Type.Literal("urgent")])),
-        dueDate: Type.Optional(Type.String()),
-        clearDueDate: Type.Optional(Type.Boolean()),
-      }),
+          priority: Type.Optional(Type.Union([Type.Literal("low"), Type.Literal("medium"), Type.Literal("high"), Type.Literal("urgent")])),
+          dueDate: Type.Optional(Type.String()),
+          clearDueDate: Type.Optional(Type.Boolean()),
+        },
+        { additionalProperties: false },
+      ),
+      executionMode: "sequential",
       async execute(_toolCallId, params): Promise<AgentToolResult<Task>> {
         const key = normalizeText(params.key, "Taskboard key", 32).toUpperCase();
         if (params.status === "done") throw new Error("Taskboard tasks must reach in_review before taskboard_accept can mark them done");
@@ -354,7 +387,8 @@ export default {
       label: "Accept taskboard task",
       description: "Accept a task in review as done after explicit confirmation.",
       promptSnippet: "accept a reviewed taskboard task as done",
-      parameters: Type.Object({ key: Type.String(), confirm: Type.Boolean() }),
+      parameters: Type.Object({ key: Type.String(), confirm: Type.Boolean() }, { additionalProperties: false }),
+      executionMode: "sequential",
       async execute(_toolCallId, params): Promise<AgentToolResult<Task>> {
         const key = normalizeText(params.key, "Taskboard key", 32).toUpperCase();
         if (params.confirm !== true) throw new Error("Accepting a task requires confirm=true");

package/packages/core/src/plugins/telemetry-blocker.ts

@@ -2,8 +2,11 @@ import type { Context } from "@deepseek-ai/cordis";
 import { Type } from "@earendil-works/pi-ai";
 import { defineTool, type AgentToolResult } from "@earendil-works/pi-coding-agent";
 import type { PiTelemetryEvent, PiTelemetryService } from "../services.js";
+import { assertKnownConfigKeys } from "../config.js";
+import z from "@deepseek-ai/schemastery";
 
 type TelemetrySnapshot = { blocked: number; names: readonly string[] };
+export const Config = z.object({});
 
 function eventName(value: string): string {
   const name = value.trim().slice(0, 80);
@@ -14,7 +17,9 @@ function eventName(value: string): string {
 export default {
   name: "pi-telemetry-blocker",
   inject: ["piPluginUi", "piTools"],
-  apply(context: Context) {
+  Config,
+  apply(context: Context, config: unknown) {
+    assertKnownConfigKeys("telemetry-blocker", config, []);
     let blocked = 0;
     const names: string[] = [];
     const record = (event: PiTelemetryEvent): { blocked: true; name: string } => {
@@ -30,7 +35,10 @@ export default {
     };
     context.provide("piTelemetry", service);
     const unsubscribe = context.on("pi/telemetry", (event) => {
-      record(event);
+      const descriptor = Object.getOwnPropertyDescriptor(event, "name");
+      if (descriptor === undefined || !("value" in descriptor)) return;
+      if (typeof descriptor.value !== "string") return;
+      record({ name: descriptor.value });
     });
     const unregisterTool = context.piTools.register(
       defineTool({
@@ -38,21 +46,29 @@ export default {
         label: "Telemetry status",
         description: "Report the local telemetry policy. Pi Harness telemetry is disabled and no event properties are retained.",
         promptSnippet: "check whether telemetry is enabled",
-        parameters: Type.Object({}),
+        parameters: Type.Object({}, { additionalProperties: false }),
+        executionMode: "sequential",
         execute(): Promise<AgentToolResult<TelemetrySnapshot>> {
           const snapshot = service.snapshot();
           return Promise.resolve({ content: [{ type: "text", text: `Telemetry disabled; blocked ${snapshot.blocked} event(s).` }], details: snapshot });
         },
       }),
     );
-    const disposePanel = context.piPluginUi.register({
-      id: "telemetry-blocker-panel",
-      pluginId: "@pi-harness/core/plugins/telemetry-blocker",
-      title: "Telemetry Blocker",
-      description: "默认关闭遥测，只保留事件名和计数，不保存事件属性。",
-      icon: "⊘",
-      read: () => ({ enabled: service.enabled, blocked, names: [...names] }),
-    });
+    let disposePanel: () => void;
+    try {
+      disposePanel = context.piPluginUi.register({
+        id: "telemetry-blocker-panel",
+        pluginId: "@pi-harness/core/plugins/telemetry-blocker",
+        title: "Telemetry Blocker",
+        description: "默认关闭遥测，只保留事件名和计数，不保存事件属性。",
+        icon: "⊘",
+        read: () => ({ enabled: service.enabled, blocked, names: [...names] }),
+      });
+    } catch (error) {
+      unregisterTool();
+      unsubscribe();
+      throw error;
+    }
     context.effect(() => () => {
       unsubscribe();
       unregisterTool();