@pi-harness/pi-harness 0.1.14 → 0.1.15

package/packages/core/src/plugins/module-search.ts

@@ -1,222 +0,0 @@
-import { lstat, readdir, stat } from "node:fs/promises";
-import { relative, resolve } 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 { readBoundedFile } from "../bounded-file.js";
-import { resolveExistingWorkspacePath } from "../workspace-path.js";
-import { EmptyConfig } from "../config.js";
-
-const maxQueryLength = 120;
-const maxPathLength = 512;
-const maxFileBytes = 2 * 1024 * 1024;
-const maxFiles = 1_000;
-const maxDirectories = 512;
-const maxDepth = 16;
-const maxResults = 100;
-const ignoredDirectories = new Set([".git", "node_modules", ".pi", "dist", "build"]);
-const sourceExtensions = new Set([".cjs", ".js", ".jsx", ".mjs", ".ts", ".tsx"]);
-
-export type ModuleMatchKind = "import" | "export" | "symbol";
-export type ModuleMatch = { kind: ModuleMatchKind; name: string; path: string; line: number; text: string };
-export type ModuleSearchKind = ModuleMatchKind | "all";
-export type ModuleSearchReport = {
-  query: string;
-  kind: ModuleSearchKind;
-  path: string;
-  matches: ModuleMatch[];
-  scannedFiles: number;
-  skippedFiles: number;
-  truncated: boolean;
-};
-
-function moduleNames(source: string, kind: ModuleMatchKind): string[] {
-  if (kind === "import") {
-    const named = [...source.matchAll(/\bimport\s*\{([^}]*)\}/gu)].flatMap(
-      (match) =>
-        match[1]
-          ?.split(",")
-          .map(
-            (item) =>
-              item
-                .trim()
-                .split(/\s+as\s+/iu)[0]
-                ?.trim() ?? "",
-          )
-          .filter(Boolean) ?? [],
-    );
-    const defaults = [...source.matchAll(/\bimport\s+([A-Za-z_$][\w$]*)\s+from\s*["']/gu)].map((match) => match[1]!).filter(Boolean);
-    const namespaces = [...source.matchAll(/\bimport\s+\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\s*["']/gu)].map((match) => match[1]!).filter(Boolean);
-    return [...named, ...defaults, ...namespaces];
-  }
-  if (kind === "export") {
-    const declarations = [...source.matchAll(/\bexport\s+(?:async\s+)?(?:function|class|const|let|var|type|interface|enum)\s+([A-Za-z_$][\w$]*)/gu)].map(
-      (match) => match[1]!,
-    );
-    const named = [...source.matchAll(/\bexport\s*\{([^}]*)\}/gu)].flatMap(
-      (match) =>
-        match[1]
-          ?.split(",")
-          .map(
-            (item) =>
-              item
-                .trim()
-                .split(/\s+as\s+/iu)
-                .at(-1)
-                ?.trim() ?? "",
-          )
-          .filter(Boolean) ?? [],
-    );
-    return [...declarations, ...named];
-  }
-  return [...source.matchAll(/\b(?:async\s+)?(?:function|class|const|let|var|type|interface|enum)\s+([A-Za-z_$][\w$]*)/gu)]
-    .map((match) => match[1]!)
-    .filter(Boolean);
-}
-
-export function extractModuleMatches(source: string, path: string, query: string, kind: ModuleSearchKind): ModuleMatch[] {
-  const normalizedQuery = query.trim().toLocaleLowerCase();
-  if (normalizedQuery.length < 1 || normalizedQuery.length > maxQueryLength) throw new Error("Module search query must contain 1-120 characters");
-  const kinds: ModuleMatchKind[] = kind === "all" ? ["import", "export", "symbol"] : [kind];
-  return source.split(/\r?\n/u).flatMap((line, index) => {
-    const matches: ModuleMatch[] = [];
-    for (const entryKind of kinds) {
-      if (kind === "all" && entryKind === "symbol" && /\bexport\b/u.test(line)) continue;
-      for (const name of moduleNames(line, entryKind)) {
-        if (!name.toLocaleLowerCase().includes(normalizedQuery)) continue;
-        matches.push({ kind: entryKind, name, path, line: index + 1, text: line });
-      }
-    }
-    return matches;
-  });
-}
-
-type WalkState = { files: string[]; directories: number };
-
-async function filesUnder(target: string, root: string, state: WalkState, depth = 0): Promise<boolean> {
-  if (state.files.length >= maxFiles || state.directories >= maxDirectories || depth > maxDepth) return true;
-  const metadata = await lstat(target);
-  if (metadata.isSymbolicLink()) return false;
-  if (metadata.isFile()) {
-    if (sourceExtensions.has(target.slice(target.lastIndexOf(".")).toLocaleLowerCase())) state.files.push(target);
-    return false;
-  }
-  if (!metadata.isDirectory()) return false;
-  state.directories += 1;
-  if (depth >= maxDepth) return true;
-  const entries = (await readdir(target, { withFileTypes: true })).sort((left, right) => left.name.localeCompare(right.name));
-  for (const entry of entries) {
-    if (state.files.length >= maxFiles || state.directories >= maxDirectories) return true;
-    if (entry.isDirectory() && ignoredDirectories.has(entry.name)) continue;
-    const child = resolve(target, entry.name);
-    if (await filesUnder(child, root, state, depth + 1)) return true;
-  }
-  return false;
-}
-
-export default {
-  name: "pi-module-search",
-  inject: ["piHarnessLaunch", "piPluginUi", "piTools"],
-  Config: EmptyConfig,
-  apply(context: Context) {
-    let latest: ModuleSearchReport | undefined;
-    const search = async (
-      query: string,
-      requestedPath: string | undefined,
-      kind: ModuleSearchKind,
-      requestedLimit: number | undefined,
-    ): Promise<ModuleSearchReport> => {
-      const normalizedQuery = query.trim();
-      if (normalizedQuery.length < 1 || normalizedQuery.length > maxQueryLength) throw new Error("Module search query must contain 1-120 characters");
-      const normalizedKind = kind === "import" || kind === "export" || kind === "symbol" ? kind : "all";
-      const requested = requestedPath?.trim() ?? ".";
-      if (requested.length > maxPathLength || requested.includes("\\"))
-        throw new Error("Module search path must be a relative POSIX path of at most 512 characters");
-      const resolved = await resolveExistingWorkspacePath(context.piHarnessLaunch.cwd, requested, "Module search path must stay inside the current workspace");
-      const root = resolved.root;
-      const target = resolved.target;
-      const targetMetadata = await stat(target);
-      const walkState: WalkState = { files: [], directories: 0 };
-      const filesTruncated = await filesUnder(target, root, walkState);
-      const files = walkState.files;
-      const limit = Math.max(1, Math.min(maxResults, Math.trunc(requestedLimit ?? maxResults)));
-      const matches: ModuleMatch[] = [];
-      let truncated = false;
-      let scannedFiles = 0;
-      let skippedFiles = targetMetadata.isFile() && targetMetadata.size > maxFileBytes ? 1 : 0;
-      for (const file of files) {
-        if (matches.length >= limit) break;
-        const metadata = await stat(file);
-        if (metadata.size > maxFileBytes) {
-          skippedFiles += 1;
-          continue;
-        }
-        let source: string;
-        try {
-          source = new TextDecoder("utf-8", { fatal: true }).decode(await readBoundedFile(file, maxFileBytes, "Module search file"));
-        } catch {
-          skippedFiles += 1;
-          continue;
-        }
-        scannedFiles += 1;
-        const fileMatches = extractModuleMatches(source, relative(root, file), normalizedQuery, normalizedKind);
-        const remaining = limit - matches.length;
-        matches.push(...fileMatches.slice(0, remaining));
-        if (fileMatches.length > remaining) truncated = true;
-      }
-      const report: ModuleSearchReport = {
-        query: normalizedQuery,
-        kind: normalizedKind,
-        path: relative(root, target) || ".",
-        matches,
-        scannedFiles,
-        skippedFiles,
-        truncated: filesTruncated || truncated || (matches.length >= limit && files.length > scannedFiles + skippedFiles),
-      };
-      latest = report;
-      return report;
-    };
-    const unregister = context.piTools.register(
-      defineTool({
-        name: "module_search",
-        label: "Search modules",
-        description: "Find imports, exports, or declared symbols in bounded workspace source files without modifying them.",
-        promptSnippet: "find a module import, export, or symbol in the workspace",
-        parameters: Type.Object(
-          {
-            query: Type.String({ description: "Name fragment to find, 1-120 characters" }),
-            kind: Type.Optional(Type.Union([Type.Literal("all"), Type.Literal("import"), Type.Literal("export"), Type.Literal("symbol")])),
-            path: Type.Optional(Type.String({ description: "Relative workspace path" })),
-            maxResults: Type.Optional(Type.Number({ description: "Maximum matches, 1-100" })),
-          },
-          { additionalProperties: false },
-        ),
-        executionMode: "sequential",
-        async execute(_toolCallId, params): Promise<AgentToolResult<ModuleSearchReport>> {
-          const report = await search(params.query, params.path, params.kind ?? "all", params.maxResults);
-          return {
-            content: [
-              {
-                type: "text",
-                text: report.matches.map((match) => `${match.path}:${match.line} ${match.kind} ${match.name}`).join("\n") || "No module matches found.",
-              },
-            ],
-            details: report,
-          };
-        },
-      }),
-    );
-    const disposePanel = context.piPluginUi.register({
-      id: "module-search-panel",
-      pluginId: "@pi-harness/core/plugins/module-search",
-      title: "Module Search",
-      description: "按导入、导出和声明符号检索工作区源码。",
-      icon: "⌕",
-      read: () => ({ latest: latest ?? null, matchCount: latest?.matches.length ?? 0 }),
-    });
-    context.effect(() => () => {
-      unregister();
-      disposePanel();
-    });
-  },
-};

package/packages/core/src/plugins/obsidian-sync.ts

@@ -1,94 +0,0 @@
-import { lstat, mkdir, realpath } from "node:fs/promises";
-import { dirname, relative, resolve } from "node:path";
-import type { Context } from "@deepseek-ai/cordis";
-import z from "@deepseek-ai/schemastery";
-import { Type } from "@earendil-works/pi-ai";
-import { defineTool, type AgentToolResult } from "@earendil-works/pi-coding-agent";
-import { atomicWriteFile } from "../atomic-write.js";
-
-const maxContentBytes = 512 * 1024;
-const maxRelativePathLength = 512;
-type SyncResult = { relativePath: string; absolutePath: string; bytes: number };
-
-export interface ObsidianSyncPluginConfig {
-  vaultPath?: string;
-}
-
-export const Config: z<ObsidianSyncPluginConfig> = z.object({ vaultPath: z.string().default("") });
-
-function isInside(root: string, target: string): boolean {
-  const remainder = relative(root, target);
-  return remainder === "" || (remainder !== ".." && !remainder.startsWith(`..${"/"}`) && !remainder.startsWith(`..${"\\"}`) && !remainder.startsWith("/"));
-}
-
-export default {
-  name: "pi-obsidian-sync",
-  inject: ["piHarnessLaunch", "piPluginUi", "piTools"],
-  Config,
-  apply(context: Context, config: ObsidianSyncPluginConfig) {
-    const configuredVault = config.vaultPath?.trim() ?? "";
-    let last: SyncResult | undefined;
-    const sync = async (relativePath: string, content: string, confirm: boolean): Promise<SyncResult> => {
-      if (configuredVault === "") throw new Error("Obsidian sync requires vaultPath in the plugin configuration");
-      if (!confirm) throw new Error("Obsidian sync requires confirm=true before writing a note");
-      if (relativePath.length === 0 || relativePath.length > maxRelativePathLength || !relativePath.toLowerCase().endsWith(".md"))
-        throw new Error("Obsidian note path must be a relative .md path of at most 512 characters");
-      if (content.length === 0 || Buffer.byteLength(content, "utf8") > maxContentBytes)
-        throw new Error(`Obsidian note content must be between 1 and ${maxContentBytes} bytes`);
-      await mkdir(configuredVault, { recursive: true });
-      const vault = await realpath(configuredVault);
-      const target = resolve(vault, relativePath);
-      if (!isInside(vault, target)) throw new Error("Obsidian note path must stay inside the configured vault");
-      const parent = dirname(target);
-      await mkdir(parent, { recursive: true });
-      if (!isInside(vault, await realpath(parent))) throw new Error("Obsidian note path must stay inside the configured vault");
-      try {
-        if ((await lstat(target)).isSymbolicLink()) throw new Error("Obsidian note target cannot be a symbolic link");
-      } catch (error) {
-        if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
-      }
-      await atomicWriteFile(target, content, { encoding: "utf8", mode: 0o600 });
-      last = { relativePath, absolutePath: target, bytes: Buffer.byteLength(content, "utf8") };
-      return last;
-    };
-    const unregisterTool = context.piTools.register(
-      defineTool({
-        name: "obsidian_sync",
-        label: "Obsidian sync",
-        description: "Write a confirmed Markdown note inside the configured Obsidian vault.",
-        promptSnippet: "save this result as a Markdown note in the Obsidian vault",
-        parameters: Type.Object(
-          {
-            relativePath: Type.String({ description: "Relative .md path inside the configured vault" }),
-            content: Type.String({ description: "Markdown note content" }),
-            confirm: Type.Boolean({ description: "Must be true to write the note" }),
-          },
-          { additionalProperties: false },
-        ),
-        executionMode: "sequential",
-        async execute(_toolCallId, params): Promise<AgentToolResult<SyncResult>> {
-          const result = await sync(params.relativePath, params.content, params.confirm);
-          return { content: [{ type: "text", text: `Obsidian note written: ${result.relativePath}` }], details: result };
-        },
-      }),
-    );
-    let disposePanel: () => void;
-    try {
-      disposePanel = context.piPluginUi.register({
-        id: "obsidian-sync-panel",
-        pluginId: "@pi-harness/core/plugins/obsidian-sync",
-        title: "Obsidian Sync",
-        description: "将 Agent 产出的 Markdown 安全写入指定 Obsidian vault。",
-        icon: "▤",
-        read: () => ({ configured: configuredVault !== "", vaultPath: configuredVault || null, last: last ?? null }),
-      });
-    } catch (error) {
-      unregisterTool();
-      throw error;
-    }
-    context.effect(() => () => {
-      unregisterTool();
-      disposePanel();
-    });
-  },
-};

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

@@ -1,260 +0,0 @@
-import type { Context } from "@deepseek-ai/cordis";
-import z from "@deepseek-ai/schemastery";
-import { Type } from "@earendil-works/pi-ai";
-import { defineTool, type AgentToolResult } from "@earendil-works/pi-coding-agent";
-import { assertKnownConfigKeys } from "../config.js";
-
-const customType = "pi-harness/openpets";
-const maxNameLength = 128;
-const maxRecoveryEntries = 10_000;
-const maxPersistenceErrorLength = 2_000;
-const parameterNames = new Set(["action", "mood"]);
-type PetMood = "idle" | "focused" | "happy" | "concerned";
-type PetParameters = { action: "status" } | { action: "feed" } | { action: "play" } | { action: "set_mood"; mood: PetMood };
-type PetState = { name: string; mood: PetMood; energy: number; interactions: number; lastEvent: string; updatedAt: string };
-type RecoveryState = { sessionEntries: number; scanned: number; truncated: boolean; restored: boolean };
-type PersistenceState = { attempts: number; failures: number; lastError: string | null };
-
-const petMoods = new Set<PetMood>(["idle", "focused", "happy", "concerned"]);
-const petEvents = new Set(["session_start", "agent_start", "agent_end", "tool_execution_end", "feed", "play", "set_mood"]);
-
-export interface OpenPetsPluginConfig {
-  name?: string;
-}
-
-export const Config: z<OpenPetsPluginConfig> = z.object({ name: z.string().min(1).max(maxNameLength).default("Pi") });
-
-function companionName(config: OpenPetsPluginConfig): string {
-  assertKnownConfigKeys("OpenPets", config, ["name"]);
-  const rawName = config.name ?? "Pi";
-  if (typeof rawName !== "string" || rawName.length === 0 || rawName.length > maxNameLength)
-    throw new Error(`OpenPets name must contain 1-${maxNameLength} characters`);
-  if (rawName.includes("\0")) throw new Error("OpenPets name must not contain NUL characters");
-  const name = rawName.trim();
-  if (name === "") throw new Error("OpenPets name must contain a non-whitespace character");
-  return name;
-}
-
-function petParameters(value: unknown): PetParameters {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error("OpenPets parameters must be an object");
-  const prototype = Object.getPrototypeOf(value) as unknown;
-  if (prototype !== Object.prototype && prototype !== null) throw new Error("OpenPets parameters must be a plain object");
-  const descriptors = Object.getOwnPropertyDescriptors(value);
-  if (Reflect.ownKeys(descriptors).some((key) => typeof key !== "string" || !parameterNames.has(key)))
-    throw new Error("OpenPets parameters contain an unknown property");
-  if (Object.values(descriptors).some((descriptor) => !("value" in descriptor))) throw new Error("OpenPets parameters must use data properties");
-  const action: unknown = descriptors.action?.value as unknown;
-  if (action !== "status" && action !== "feed" && action !== "play" && action !== "set_mood")
-    throw new Error("OpenPets action must be status, feed, play, or set_mood");
-  const mood: unknown = descriptors.mood?.value as unknown;
-  if (action !== "set_mood") {
-    if (mood !== undefined) throw new Error("OpenPets mood is only allowed for set_mood");
-    return { action };
-  }
-  if (mood !== "idle" && mood !== "focused" && mood !== "happy" && mood !== "concerned")
-    throw new Error("OpenPets mood must be idle, focused, happy, or concerned");
-  return { action, mood };
-}
-
-function throwIfCancelled(signal: AbortSignal | undefined): void {
-  if (signal?.aborted === true) throw new Error("OpenPets action was cancelled", { cause: signal.reason });
-}
-
-function petSessionEvent(value: unknown): "agent_start" | "agent_end" | "tool_error" | undefined {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) return undefined;
-  const descriptors = Object.getOwnPropertyDescriptors(value);
-  const typeDescriptor = descriptors.type;
-  if (typeDescriptor === undefined || !("value" in typeDescriptor)) return undefined;
-  if (typeDescriptor.value === "agent_start") return "agent_start";
-  if (typeDescriptor.value === "agent_end") return "agent_end";
-  if (typeDescriptor.value !== "tool_execution_end") return undefined;
-  const errorDescriptor = descriptors.isError;
-  return errorDescriptor !== undefined && "value" in errorDescriptor && errorDescriptor.value === true ? "tool_error" : undefined;
-}
-
-function clampEnergy(value: number): number {
-  return Math.max(0, Math.min(100, Math.round(value)));
-}
-
-function incrementInteractions(value: number): number {
-  return value >= Number.MAX_SAFE_INTEGER ? Number.MAX_SAFE_INTEGER : value + 1;
-}
-
-function incrementCount(value: number): number {
-  return value >= Number.MAX_SAFE_INTEGER ? Number.MAX_SAFE_INTEGER : value + 1;
-}
-
-function boundedPersistenceError(error: unknown): string {
-  if (typeof error === "string") return error.slice(0, maxPersistenceErrorLength);
-  if (error !== null && typeof error === "object") {
-    const descriptor = Object.getOwnPropertyDescriptor(error, "message");
-    if (descriptor !== undefined && "value" in descriptor && typeof descriptor.value === "string") return descriptor.value.slice(0, maxPersistenceErrorLength);
-  }
-  return "Unknown OpenPets persistence error";
-}
-
-function initialState(name: string): PetState {
-  return { name, mood: "idle", energy: 80, interactions: 0, lastEvent: "session_start", updatedAt: new Date(0).toISOString() };
-}
-
-function validTimestamp(value: unknown): value is string {
-  if (typeof value !== "string" || value.length > 64) return false;
-  try {
-    return new Date(value).toISOString() === value;
-  } catch {
-    return false;
-  }
-}
-
-function persistedState(value: unknown, name: string): PetState | undefined {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) return undefined;
-  const prototype = Object.getPrototypeOf(value) as unknown;
-  if (prototype !== Object.prototype && prototype !== null) return undefined;
-  const descriptors = Object.getOwnPropertyDescriptors(value);
-  if (Reflect.ownKeys(descriptors).some((key) => typeof key !== "string") || Object.values(descriptors).some((descriptor) => !("value" in descriptor)))
-    return undefined;
-  const mood = descriptors.mood?.value as unknown;
-  const energy = descriptors.energy?.value as unknown;
-  const interactions = descriptors.interactions?.value as unknown;
-  const lastEvent = descriptors.lastEvent?.value as unknown;
-  const updatedAt = descriptors.updatedAt?.value as unknown;
-  return {
-    name,
-    mood: typeof mood === "string" && petMoods.has(mood as PetMood) ? (mood as PetMood) : "idle",
-    energy: typeof energy === "number" && Number.isSafeInteger(energy) && energy >= 0 && energy <= 100 ? energy : 80,
-    interactions: typeof interactions === "number" && Number.isSafeInteger(interactions) && interactions >= 0 ? interactions : 0,
-    lastEvent: typeof lastEvent === "string" && petEvents.has(lastEvent) ? lastEvent : "session_start",
-    updatedAt: validTimestamp(updatedAt) ? updatedAt : new Date(0).toISOString(),
-  };
-}
-
-function entryData(entry: unknown): unknown {
-  if (entry === null || typeof entry !== "object" || Array.isArray(entry)) return undefined;
-  const descriptors = Object.getOwnPropertyDescriptors(entry);
-  if (!Object.values(descriptors).every((descriptor) => "value" in descriptor)) return undefined;
-  if (descriptors.type?.value !== "custom" || descriptors.customType?.value !== customType) return undefined;
-  return descriptors.data?.value;
-}
-
-function readState(context: Context, name: string): { state: PetState; recovery: RecoveryState } {
-  const entries = context.piSession.manager.getEntries();
-  const scanned = Math.min(entries.length, maxRecoveryEntries);
-  const recovery: RecoveryState = { sessionEntries: entries.length, scanned, truncated: entries.length > scanned, restored: false };
-  for (let index = entries.length - 1; index >= entries.length - scanned; index -= 1) {
-    const data = entryData(entries[index]);
-    if (data === undefined) continue;
-    const state = persistedState(data, name);
-    if (state !== undefined) return { state, recovery: { ...recovery, restored: true } };
-  }
-  return { state: initialState(name), recovery };
-}
-
-export default {
-  name: "pi-openpets",
-  inject: ["piSession", "piPluginUi", "piTools"],
-  Config,
-  apply(context: Context, config: OpenPetsPluginConfig) {
-    const name = companionName(config);
-    const recovered = readState(context, name);
-    let state = recovered.state;
-    const persistence: PersistenceState = { attempts: 0, failures: 0, lastError: null };
-    const persist = (next: PetState): void => {
-      persistence.attempts = incrementCount(persistence.attempts);
-      try {
-        context.piSession.manager.appendCustomEntry(customType, { ...next });
-        persistence.lastError = null;
-      } catch (error) {
-        persistence.failures = incrementCount(persistence.failures);
-        persistence.lastError = boundedPersistenceError(error);
-        throw error instanceof Error ? error : new Error("OpenPets persistence failed with a non-Error reason", { cause: error });
-      }
-    };
-    const update = (next: Partial<PetState>, persistState = true): PetState => {
-      state = { ...state, ...next, name, updatedAt: new Date().toISOString() };
-      if (persistState) persist(state);
-      return { ...state };
-    };
-    const unsubscribe = context.on("pi/session-event", (event) => {
-      const type = petSessionEvent(event);
-      try {
-        if (type === "agent_start") update({ mood: "focused", energy: clampEnergy(state.energy - 5), lastEvent: type });
-        else if (type === "agent_end") update({ mood: "happy", energy: clampEnergy(state.energy + 5), lastEvent: type });
-        else if (type === "tool_error" && (state.mood !== "concerned" || state.lastEvent !== "tool_execution_end"))
-          update({ mood: "concerned", lastEvent: "tool_execution_end" });
-      } catch {
-        // Session-event observers must not unwind the Agent run. The panel exposes the bounded persistence failure.
-      }
-    });
-    const unregisterTool = context.piTools.register(
-      defineTool({
-        name: "pet_react",
-        label: "Pet companion",
-        description: "Read or update the local OpenPets companion state for the current Pi session.",
-        promptSnippet: "check the companion state or let the pet react",
-        parameters: Type.Object(
-          {
-            action: Type.Union([Type.Literal("status"), Type.Literal("feed"), Type.Literal("play"), Type.Literal("set_mood")]),
-            mood: Type.Optional(Type.Union([Type.Literal("idle"), Type.Literal("focused"), Type.Literal("happy"), Type.Literal("concerned")])),
-          },
-          { additionalProperties: false },
-        ),
-        executionMode: "sequential",
-        execute(_toolCallId, rawParams, signal): Promise<AgentToolResult<PetState>> {
-          return Promise.resolve().then(() => {
-            const params = petParameters(rawParams);
-            throwIfCancelled(signal);
-            if (params.action === "status")
-              return {
-                content: [{ type: "text" as const, text: `${state.name}: ${state.mood}, energy ${state.energy}` }],
-                details: { ...state },
-              };
-            if (params.action === "feed")
-              return {
-                content: [{ type: "text" as const, text: `${state.name} is refreshed.` }],
-                details: update({ mood: "happy", energy: 100, interactions: incrementInteractions(state.interactions), lastEvent: "feed" }),
-              };
-            if (params.action === "play")
-              return {
-                content: [{ type: "text" as const, text: `${state.name} had a play break.` }],
-                details: update({
-                  mood: "happy",
-                  energy: clampEnergy(state.energy + 10),
-                  interactions: incrementInteractions(state.interactions),
-                  lastEvent: "play",
-                }),
-              };
-            return {
-              content: [{ type: "text" as const, text: `${state.name} mood set to ${params.mood}.` }],
-              details: update({ mood: params.mood, interactions: incrementInteractions(state.interactions), lastEvent: "set_mood" }),
-            };
-          });
-        },
-      }),
-    );
-    let disposePanel: () => void;
-    try {
-      disposePanel = context.piPluginUi.register({
-        id: "openpets-panel",
-        pluginId: "@pi-harness/core/plugins/openpets",
-        title: "OpenPets",
-        description: "根据 Pi 会话事件反应的本地桌面伙伴状态。",
-        icon: "◉",
-        read: () => ({
-          ...state,
-          recovery: { ...recovered.recovery },
-          persistence: { ...persistence },
-          limits: { nameCharacters: maxNameLength, recoveryEntries: maxRecoveryEntries, persistenceErrorCharacters: maxPersistenceErrorLength },
-        }),
-      });
-    } catch (error) {
-      unsubscribe();
-      unregisterTool();
-      throw error;
-    }
-    context.effect(() => () => {
-      unsubscribe();
-      unregisterTool();
-      disposePanel();
-    });
-  },
-};