@pi-harness/pi-harness 0.1.13 → 0.1.14

package/packages/core/src/plugins/docker-sandbox.ts

@@ -1,98 +1,334 @@
 import { execFile } from "node:child_process";
-import { basename } from "node:path";
+import { randomUUID } from "node:crypto";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, join } from "node:path";
 import { promisify } from "node:util";
+import { stripVTControlCharacters } from "node:util";
+import { EmptyConfig } from "../config.js";
 import type { Context } from "@deepseek-ai/cordis";
 import { Type } from "@earendil-works/pi-ai";
 import { defineTool, type AgentToolResult } from "@earendil-works/pi-coding-agent";
 
 const execFileAsync = promisify(execFile);
-const shellCommands = new Set(["sh", "bash", "zsh", "fish", "cmd", "powershell", "pwsh"]);
-type SandboxRun = { image: string; command: string[]; write: boolean; exitCode: number; output: string };
+const defaultImage = "alpine:3.20";
+const maxArgs = 128;
+const maxArgLength = 16_384;
+const maxCommandLength = 128 * 1024;
+const maxImageLength = 512;
+const maxOutputBytes = 12_000;
+const inspectTimeoutMs = 30_000;
+const runTimeoutMs = 120_000;
+const cleanupTimeoutMs = 10_000;
+const memoryLimit = "512m";
+const cpuLimit = "1";
+const processLimit = 256;
+const shellCommands = new Set(["ash", "bash", "cmd", "csh", "dash", "fish", "ksh", "powershell", "pwsh", "sh", "tcsh", "zsh"]);
+const unsafeUnicode = /[\p{Cc}\p{Cf}\p{Cs}\u2028\u2029]/u;
+
+type SandboxStatus = "completed" | "failed" | "timed_out";
+type SandboxRun = { image: string; command: string[]; write: boolean; exitCode: number; status: SandboxStatus; output: string };
+type SandboxParameters = { command: string[]; image?: string; write: boolean; confirmWrite: boolean };
+
+function throwIfAborted(signal: AbortSignal): void {
+  if (!signal.aborted) return;
+  throw signal.reason instanceof Error ? signal.reason : new Error("Docker sandbox operation was cancelled", { cause: signal.reason });
+}
 
 function validateImage(image: string): void {
+  if (image.length > maxImageLength) throw new Error(`Docker image reference must contain at most ${maxImageLength} characters`);
   if (!/^[a-zA-Z0-9][a-zA-Z0-9._/@:-]*$/.test(image)) throw new Error("Invalid Docker image reference");
 }
 
+function executableName(executable: string): string {
+  const portable = executable.replaceAll("\\", "/");
+  const name = basename(portable).toLowerCase();
+  return name.endsWith(".exe") ? name.slice(0, -4) : name;
+}
+
+function validateParameters(value: unknown): SandboxParameters {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error("Docker sandbox parameters must be an object with a command array");
+  let descriptors: PropertyDescriptorMap;
+  try {
+    const prototype = Object.getPrototypeOf(value) as unknown;
+    if (prototype !== Object.prototype && prototype !== null) throw new Error("Docker sandbox parameters must be a plain object");
+    descriptors = Object.getOwnPropertyDescriptors(value);
+  } catch (error) {
+    if (error instanceof Error && error.message === "Docker sandbox parameters must be a plain object") throw error;
+    throw new Error("Docker sandbox parameters must be an accessible plain object", { cause: error });
+  }
+  const allowed = new Set(["command", "image", "write", "confirmWrite"]);
+  if (Reflect.ownKeys(descriptors).some((key) => typeof key !== "string" || !allowed.has(key)))
+    throw new Error("Docker sandbox parameters contain an unknown property");
+  for (const descriptor of Object.values(descriptors)) {
+    if ("get" in descriptor || "set" in descriptor) throw new Error("Docker sandbox parameters must use data properties");
+  }
+
+  const rawCommand: unknown = descriptors.command?.value;
+  if (!Array.isArray(rawCommand)) throw new Error("Docker sandbox command must be an array");
+  let commandDescriptors: PropertyDescriptorMap;
+  try {
+    if (Object.getPrototypeOf(rawCommand) !== Array.prototype) throw new Error("Sandbox command must be a plain array");
+    commandDescriptors = Object.getOwnPropertyDescriptors(rawCommand) as unknown as PropertyDescriptorMap;
+  } catch (error) {
+    if (error instanceof Error && error.message === "Sandbox command must be a plain array") throw error;
+    throw new Error("Sandbox command must be an accessible plain array", { cause: error });
+  }
+  if (
+    Reflect.ownKeys(commandDescriptors).some(
+      (key) => key !== "length" && (typeof key !== "string" || !/^\d+$/u.test(key) || Number(key) >= rawCommand.length || String(Number(key)) !== key),
+    )
+  )
+    throw new Error("Sandbox command contains an unknown property");
+  const lengthDescriptor = commandDescriptors.length;
+  if (lengthDescriptor === undefined || !("value" in lengthDescriptor) || lengthDescriptor.value !== rawCommand.length)
+    throw new Error("Sandbox command length must be a data property");
+  if (rawCommand.length === 0) throw new Error("Sandbox command cannot be empty");
+  if (rawCommand.length > maxArgs) throw new Error(`Sandbox command must contain at most ${maxArgs} arguments`);
+  const command: string[] = [];
+  let totalLength = 0;
+  for (let index = 0; index < rawCommand.length; index += 1) {
+    const descriptor = commandDescriptors[String(index)];
+    if (descriptor === undefined || "get" in descriptor || "set" in descriptor) throw new Error("Sandbox command arguments must be string data properties");
+    const argument: unknown = descriptor.value;
+    if (typeof argument !== "string") throw new Error("Sandbox command arguments must be string data properties");
+    if (argument.length === 0) throw new Error("Sandbox command arguments cannot be empty");
+    if (Buffer.byteLength(argument, "utf8") > maxArgLength) throw new Error(`Sandbox command arguments must contain at most ${maxArgLength} bytes`);
+    if (argument.includes("\0")) throw new Error("Sandbox command arguments cannot contain NUL characters");
+    totalLength += Buffer.byteLength(argument, "utf8");
+    if (totalLength > maxCommandLength) throw new Error(`Sandbox command must contain at most ${maxCommandLength} bytes in total`);
+    command.push(argument);
+  }
+
+  const rawImage: unknown = descriptors.image?.value;
+  if (rawImage !== undefined && typeof rawImage !== "string") throw new Error("Docker sandbox image must be a string");
+  if (typeof rawImage === "string" && rawImage.trim() === "") throw new Error("Docker sandbox image must be non-empty");
+  if (typeof rawImage === "string" && rawImage.length > maxImageLength)
+    throw new Error(`Docker image reference must contain at most ${maxImageLength} characters`);
+  const rawWrite: unknown = descriptors.write?.value;
+  if (rawWrite !== undefined && typeof rawWrite !== "boolean") throw new Error("Docker sandbox write must be a boolean");
+  const rawConfirmWrite: unknown = descriptors.confirmWrite?.value;
+  if (rawConfirmWrite !== undefined && typeof rawConfirmWrite !== "boolean") throw new Error("Docker sandbox confirmWrite must be a boolean");
+  return { command, ...(rawImage === undefined ? {} : { image: rawImage }), write: rawWrite === true, confirmWrite: rawConfirmWrite === true };
+}
+
+function csvField(key: string, value: string): string {
+  return `"${`${key}=${value}`.replaceAll('"', '""')}"`;
+}
+
+function cloneRun(run: SandboxRun): SandboxRun {
+  return { ...run, command: [...run.command] };
+}
+
+function boundedOutput(value: string): string {
+  const bytes = Buffer.from(value, "utf8");
+  if (bytes.length <= maxOutputBytes) return value;
+  let start = bytes.length - maxOutputBytes;
+  while (start < bytes.length && (bytes[start]! & 0xc0) === 0x80) start += 1;
+  return bytes.subarray(start).toString("utf8");
+}
+
+function safeOutput(value: string): string {
+  const withoutTerminalSequences = stripVTControlCharacters(value);
+  let normalized = "";
+  for (const character of withoutTerminalSequences) {
+    normalized += unsafeUnicode.test(character) && character !== "\t" && character !== "\n" ? "�" : character;
+  }
+  return boundedOutput(normalized.replaceAll(/\r\n?/gu, "\n"));
+}
+
+function outputFromFailure(failure: { stdout?: string; stderr?: string; message?: string }): string {
+  return safeOutput(`${failure.stdout ?? ""}${failure.stderr ?? failure.message ?? ""}`);
+}
+
+async function containerId(cidfile: string): Promise<string | undefined> {
+  try {
+    const id = (await readFile(cidfile, "utf8")).trim();
+    return /^[a-f0-9]{64}$/iu.test(id) ? id : undefined;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+    throw error;
+  }
+}
+
+async function removeOwnedContainer(id: string): Promise<void> {
+  try {
+    await execFileAsync("docker", ["rm", "--force", id], {
+      timeout: cleanupTimeoutMs,
+      maxBuffer: 1_000_000,
+      windowsHide: true,
+    });
+  } catch (error) {
+    const failure = error as { stdout?: string; stderr?: string; message?: string };
+    const detail = outputFromFailure(failure);
+    if (/No such container/iu.test(detail)) return;
+    throw new Error(`Docker sandbox container cleanup could not be confirmed: ${detail.slice(-1_024) || "unknown Docker error"}`, { cause: error });
+  }
+}
+
 export default {
   name: "pi-docker-sandbox",
   inject: ["piHarnessLaunch", "piPluginUi", "piTools"],
+  Config: EmptyConfig,
   apply(context: Context) {
     let latest: SandboxRun | undefined;
-    const unregisterTool = context.piTools.register(
-      defineTool({
-        name: "sandbox_exec",
-        label: "Docker sandbox",
-        description: "Run an argv command in a no-network Docker container with the workspace mounted read-only by default.",
-        promptSnippet: "run a command in an isolated no-network Docker sandbox",
-        parameters: Type.Object({
-          command: Type.Array(Type.String(), { description: "Executable and arguments; shell wrappers are rejected" }),
-          image: Type.Optional(Type.String({ description: "Local Docker image, default alpine:3.20" })),
-          write: Type.Optional(Type.Boolean({ description: "Mount the workspace read-write" })),
-          confirmWrite: Type.Optional(Type.Boolean({ description: "Must be true when write is enabled" })),
-        }),
-        async execute(_toolCallId, params): Promise<AgentToolResult<SandboxRun>> {
-          if (params.command.length === 0) throw new Error("Sandbox command cannot be empty");
-          const executable = params.command[0];
-          if (executable === undefined) throw new Error("Sandbox command cannot be empty");
-          if (shellCommands.has(basename(executable).toLowerCase())) throw new Error("Shell wrappers are not allowed; pass an executable argv directly");
-          const image = params.image?.trim() || "alpine:3.20";
-          validateImage(image);
-          const write = params.write === true;
-          if (write && params.confirmWrite !== true) throw new Error("Writable sandbox requires confirmWrite=true");
-          try {
-            await execFileAsync("docker", ["image", "inspect", image], { timeout: 30_000, maxBuffer: 1_000_000 });
-          } catch (error) {
-            const failure = error as { code?: number | string; message?: string };
-            if (failure.code === "ENOENT") throw new Error("Docker executable is not available on PATH", { cause: error });
-            throw new Error(`Docker image is not available locally: ${image}`, { cause: error });
-          }
-          const args = [
-            "run",
-            "--rm",
-            "--network",
-            "none",
-            "--read-only",
-            "--tmpfs",
-            "/tmp:rw,noexec,nosuid",
-            "--cap-drop",
-            "ALL",
-            "--security-opt",
-            "no-new-privileges",
-            "--pids-limit",
-            "256",
-            "--mount",
-            `type=bind,src=${context.piHarnessLaunch.cwd},dst=/workspace${write ? "" : ",readonly"}`,
-            "--workdir",
-            "/workspace",
-            image,
-            ...params.command,
-          ];
-          try {
-            const result = await execFileAsync("docker", args, { cwd: context.piHarnessLaunch.cwd, timeout: 120_000, maxBuffer: 4 * 1024 * 1024 });
-            latest = { image, command: [...params.command], write, exitCode: 0, output: `${result.stdout}${result.stderr}`.slice(-12_000) };
-          } catch (error) {
-            const failure = error as { code?: number | string; stdout?: string; stderr?: string; message?: string };
-            latest = {
+    const lifecycle = new AbortController();
+    let unregisterTool: () => void = () => undefined;
+    let disposePanel: () => void = () => undefined;
+    try {
+      unregisterTool = context.piTools.register(
+        defineTool({
+          name: "sandbox_exec",
+          label: "Docker sandbox",
+          description: "Run a bounded argv command in a no-network Docker container using an explicitly local image and a read-only workspace by default.",
+          promptSnippet: "run a bounded command in an isolated no-network Docker sandbox",
+          parameters: Type.Object(
+            {
+              command: Type.Array(Type.String({ minLength: 1, maxLength: maxArgLength }), {
+                minItems: 1,
+                maxItems: maxArgs,
+                description: "Executable and arguments; shell wrappers are rejected",
+              }),
+              image: Type.Optional(Type.String({ minLength: 1, maxLength: maxImageLength, description: `Local Docker image, default ${defaultImage}` })),
+              write: Type.Optional(Type.Boolean({ description: "Mount the workspace read-write" })),
+              confirmWrite: Type.Optional(Type.Boolean({ description: "Must be true when write is enabled" })),
+            },
+            { additionalProperties: false },
+          ),
+          executionMode: "sequential",
+          async execute(_toolCallId, rawParams, signal): Promise<AgentToolResult<SandboxRun>> {
+            const operationSignal = signal === undefined ? lifecycle.signal : AbortSignal.any([signal, lifecycle.signal]);
+            throwIfAborted(operationSignal);
+            const params = validateParameters(rawParams);
+            const executable = params.command[0]!;
+            if (shellCommands.has(executableName(executable))) throw new Error("Shell wrappers are not allowed; pass an executable argv directly");
+            const image = params.image?.trim() || defaultImage;
+            validateImage(image);
+            if (params.write && !params.confirmWrite) throw new Error("Writable sandbox requires confirmWrite=true");
+            try {
+              await execFileAsync("docker", ["image", "inspect", image], {
+                timeout: inspectTimeoutMs,
+                maxBuffer: 1_000_000,
+                signal: operationSignal,
+                windowsHide: true,
+              });
+            } catch (error) {
+              throwIfAborted(operationSignal);
+              const failure = error as { code?: number | string };
+              if (failure.code === "ENOENT") throw new Error("Docker executable is not available on PATH", { cause: error });
+              throw new Error(`Docker image is not available locally: ${image}`, { cause: error });
+            }
+
+            const temporaryDirectory = await mkdtemp(join(tmpdir(), "pi-harness-docker-sandbox-"));
+            const cidfile = join(temporaryDirectory, "container.cid");
+            const containerName = `pi-harness-sandbox-${randomUUID()}`;
+            const mount = `type=bind,${csvField("src", context.piHarnessLaunch.cwd)},dst=/workspace${params.write ? "" : ",readonly"}`;
+            const args = [
+              "run",
+              "--rm",
+              "--name",
+              containerName,
+              "--cidfile",
+              cidfile,
+              "--pull=never",
+              "--network",
+              "none",
+              "--read-only",
+              "--tmpfs",
+              "/tmp:rw,noexec,nosuid",
+              "--cap-drop",
+              "ALL",
+              "--security-opt",
+              "no-new-privileges",
+              "--memory",
+              memoryLimit,
+              "--cpus",
+              cpuLimit,
+              "--pids-limit",
+              String(processLimit),
+              "--mount",
+              mount,
+              "--workdir",
+              "/workspace",
               image,
-              command: [...params.command],
-              write,
-              exitCode: typeof failure.code === "number" ? failure.code : 1,
-              output: `${failure.stdout ?? ""}${failure.stderr ?? failure.message ?? ""}`.slice(-12_000),
-            };
-          }
-          return { content: [{ type: "text", text: `Docker sandbox exited with ${latest.exitCode}.\n${latest.output}` }], details: latest };
-        },
-      }),
-    );
-    const disposePanel = context.piPluginUi.register({
-      id: "docker-sandbox-panel",
-      pluginId: "@pi-harness/core/plugins/docker-sandbox",
-      title: "Docker Sandbox",
-      description: "无网络、只读挂载、去除 Linux capabilities 的隔离执行环境。",
-      icon: "⬡",
-      read: () => ({ latest: latest ?? null, defaults: { network: "none", workspace: "read-only", image: "alpine:3.20" } }),
-    });
+              ...params.command,
+            ];
+            try {
+              try {
+                const result = await execFileAsync("docker", args, {
+                  cwd: context.piHarnessLaunch.cwd,
+                  timeout: runTimeoutMs,
+                  maxBuffer: 4 * 1024 * 1024,
+                  signal: operationSignal,
+                  windowsHide: true,
+                });
+                const run: SandboxRun = {
+                  image,
+                  command: [...params.command],
+                  write: params.write,
+                  exitCode: 0,
+                  status: "completed",
+                  output: safeOutput(`${result.stdout}${result.stderr}`),
+                };
+                latest = cloneRun(run);
+                return {
+                  content: [{ type: "text", text: `Docker sandbox exited with ${run.exitCode}.\n${run.output}` }],
+                  details: cloneRun(run),
+                };
+              } catch (error) {
+                const id = await containerId(cidfile);
+                await removeOwnedContainer(id ?? containerName);
+                throwIfAborted(operationSignal);
+                const failure = error as { code?: number | string; killed?: boolean; stdout?: string; stderr?: string; message?: string };
+                const run: SandboxRun = {
+                  image,
+                  command: [...params.command],
+                  write: params.write,
+                  exitCode: typeof failure.code === "number" ? failure.code : 1,
+                  status: failure.killed === true ? "timed_out" : "failed",
+                  output: outputFromFailure(failure),
+                };
+                latest = cloneRun(run);
+                return {
+                  content: [{ type: "text", text: `Docker sandbox exited with ${run.exitCode}.\n${run.output}` }],
+                  details: cloneRun(run),
+                };
+              }
+            } finally {
+              await rm(temporaryDirectory, { force: true, recursive: true });
+            }
+          },
+        }),
+      );
+      disposePanel = context.piPluginUi.register({
+        id: "docker-sandbox-panel",
+        pluginId: "@pi-harness/core/plugins/docker-sandbox",
+        title: "Docker Sandbox",
+        description: "仅使用本地镜像，并以无网络、只读根文件系统和有界资源运行 argv 命令。工作区默认只读。",
+        icon: "⬡",
+        read: () => ({
+          latest: latest === undefined ? null : cloneRun(latest),
+          defaults: {
+            network: "none",
+            rootFilesystem: "read-only",
+            workspace: "read-only",
+            image: defaultImage,
+            pull: "never",
+            memory: memoryLimit,
+            cpus: Number(cpuLimit),
+            pids: processLimit,
+            timeoutMs: runTimeoutMs,
+          },
+        }),
+      });
+    } catch (error) {
+      disposePanel();
+      unregisterTool();
+      lifecycle.abort(new Error("Docker sandbox plugin registration failed"));
+      throw error;
+    }
     context.effect(() => () => {
+      lifecycle.abort(new Error("Docker sandbox plugin disposed"));
       unregisterTool();
       disposePanel();
     });

package/packages/core/src/plugins/fail-logger.ts

@@ -1,46 +1,197 @@
 import type { Context } from "@deepseek-ai/cordis";
+import { EmptyConfig } from "../config.js";
 
-type Failure = { time: string; source: string; message: string };
+const maxFailures = 50;
+const maxMessageLength = 2_048;
+const maxPathLength = 512;
+const maxPreviewStringLength = 512;
+const maxPreviewProperties = 12;
+const maxPreviewDepth = 3;
+const maxPreviewNodes = 64;
+const maxAgentMessagesScanned = 10_000;
+
+type Failure = { time: string; source: string; message: string; occurrences: number };
+type PreviewState = { remaining: number; readonly seen: WeakSet<object> };
+
+function boundedText(value: string, limit: number): string {
+  if (value.length <= limit) return value.replaceAll("\0", "�");
+  return value.slice(0, limit - 1).replaceAll("\0", "�") + "…";
+}
+
+function incrementCount(value: number): number {
+  return value >= Number.MAX_SAFE_INTEGER ? Number.MAX_SAFE_INTEGER : value + 1;
+}
+
+function preview(value: unknown, state: PreviewState, depth = 0): unknown {
+  if (state.remaining <= 0) return "[Truncated]";
+  state.remaining -= 1;
+  if (value === null || typeof value === "boolean") return value;
+  if (typeof value === "string") return boundedText(value, maxPreviewStringLength);
+  if (typeof value === "number") return Number.isFinite(value) ? value : String(value);
+  if (typeof value === "bigint") return value.toString();
+  if (typeof value === "undefined") return "[Undefined]";
+  if (typeof value === "function") return "[Function]";
+  if (typeof value === "symbol") return String(value);
+  if (typeof value !== "object") return "[Unknown]";
+  if (depth >= maxPreviewDepth) return "[Max Depth]";
+  if (state.seen.has(value)) return "[Circular]";
+  state.seen.add(value);
+
+  try {
+    if (Array.isArray(value)) {
+      const output: unknown[] = [];
+      const lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
+      const rawLength: unknown = lengthDescriptor !== undefined && "value" in lengthDescriptor ? lengthDescriptor.value : 0;
+      const arrayLength = typeof rawLength === "number" && Number.isSafeInteger(rawLength) && rawLength >= 0 ? rawLength : 0;
+      const length = Math.min(arrayLength, maxPreviewProperties);
+      for (let index = 0; index < length; index += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+        output.push(descriptor === undefined ? null : "value" in descriptor ? preview(descriptor.value as unknown, state, depth + 1) : "[Accessor]");
+      }
+      if (arrayLength > maxPreviewProperties) output.push(`[${arrayLength - maxPreviewProperties} more items]`);
+      return output;
+    }
+    const entries: Array<readonly [string, unknown]> = [];
+    for (const key of ["name", "message", "code", "reason", "detail", "cause", "attempt"]) {
+      const property = dataProperty(value, key);
+      if (!property.present) continue;
+      entries.push([key, property.accessor ? "[Accessor]" : preview(property.value, state, depth + 1)]);
+    }
+    return entries.length === 0 ? "[Object failure]" : Object.fromEntries(entries);
+  } catch {
+    return "[Unavailable]";
+  }
+}
+
+function previewText(value: unknown): string {
+  if (typeof value === "string") return boundedText(value, maxMessageLength);
+  if (typeof value === "object" && value !== null) {
+    const message = dataProperty(value, "message");
+    if (!message.accessor && typeof message.value === "string" && message.value.trim() !== "") return boundedText(message.value, maxMessageLength);
+  }
+  const sanitized = preview(value, { remaining: maxPreviewNodes, seen: new WeakSet<object>() });
+  try {
+    return boundedText(typeof sanitized === "string" ? sanitized : JSON.stringify(sanitized), maxMessageLength);
+  } catch {
+    return "[Unavailable failure]";
+  }
+}
+
+function dataProperty(value: object, key: string): { present: boolean; value?: unknown; accessor: boolean } {
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (descriptor === undefined) return { present: false, accessor: false };
+    if (!("value" in descriptor)) return { present: true, accessor: true };
+    return { present: true, value: descriptor.value as unknown, accessor: false };
+  } catch {
+    return { present: true, accessor: true };
+  }
+}
+
+function findAgentFailure(event: object): unknown {
+  const messagesProperty = dataProperty(event, "messages");
+  if (messagesProperty.accessor || typeof messagesProperty.value !== "object" || messagesProperty.value === null) return undefined;
+  const lengthProperty = dataProperty(messagesProperty.value, "length");
+  const length = lengthProperty.accessor ? undefined : lengthProperty.value;
+  if (typeof length !== "number" || !Number.isSafeInteger(length) || length <= 0) return undefined;
+  const firstIndex = Math.max(0, length - maxAgentMessagesScanned);
+  for (let index = length - 1; index >= firstIndex; index -= 1) {
+    const messageProperty = dataProperty(messagesProperty.value, String(index));
+    if (messageProperty.accessor || typeof messageProperty.value !== "object" || messageProperty.value === null) continue;
+    const role = dataProperty(messageProperty.value, "role");
+    const stopReason = dataProperty(messageProperty.value, "stopReason");
+    if (role.accessor || stopReason.accessor || role.value !== "assistant" || stopReason.value !== "error") continue;
+    const errorMessage = dataProperty(messageProperty.value, "errorMessage");
+    if (errorMessage.accessor || errorMessage.value === undefined || (typeof errorMessage.value === "string" && errorMessage.value.trim() === ""))
+      return "Agent turn failed";
+    return errorMessage.value;
+  }
+  return undefined;
+}
 
 function messageOf(error: unknown): string {
-  if (error instanceof Error) return error.message;
-  if (typeof error === "object" && error !== null && "error" in error) {
-    const { error: message, extensionPath } = error as { error: unknown; extensionPath?: unknown };
-    const text = typeof message === "string" ? message : String(message);
-    return typeof extensionPath === "string" ? `${extensionPath}: ${text}` : text;
+  try {
+    if (typeof error === "object" && error !== null) {
+      const nested = dataProperty(error, "error");
+      if (nested.present) {
+        const message = nested.accessor ? "[Accessor]" : previewText(nested.value);
+        const path = dataProperty(error, "extensionPath");
+        const pathText = !path.accessor && typeof path.value === "string" ? boundedText(path.value, maxPathLength) : "";
+        return boundedText(pathText === "" ? message : `${pathText}: ${message}`, maxMessageLength);
+      }
+    }
+    return boundedText(previewText(error), maxMessageLength);
+  } catch {
+    return "[Unavailable failure]";
   }
-  return typeof error === "string" ? error : (JSON.stringify(error) ?? String(error));
+}
+
+function cloneFailure(failure: Failure): Failure {
+  return { ...failure };
 }
 
 export default {
   name: "pi-fail-logger",
   inject: ["piPluginUi"],
+  Config: EmptyConfig,
   apply(context: Context) {
     const failures: Failure[] = [];
-    let previous: string | undefined;
+    const indexed = new Map<string, Failure>();
+    let observed = 0;
+    let dropped = 0;
     const record = (source: string, error: unknown): void => {
+      observed = incrementCount(observed);
       const message = messageOf(error);
       const fingerprint = `${source}:${message}`;
-      if (fingerprint === previous) return;
-      previous = fingerprint;
-      failures.push({ time: new Date().toISOString(), source, message });
-      if (failures.length > 50) failures.shift();
+      const existing = indexed.get(fingerprint);
+      const time = new Date().toISOString();
+      if (existing !== undefined) {
+        existing.time = time;
+        existing.occurrences = incrementCount(existing.occurrences);
+        const index = failures.indexOf(existing);
+        if (index >= 0) failures.splice(index, 1);
+        failures.push(existing);
+        return;
+      }
+      const failure = { time, source, message, occurrences: 1 };
+      indexed.set(fingerprint, failure);
+      failures.push(failure);
+      if (failures.length > maxFailures) {
+        const removed = failures.shift();
+        if (removed !== undefined) indexed.delete(`${removed.source}:${removed.message}`);
+        dropped = incrementCount(dropped);
+      }
     };
     const unsubscribeExtension = context.on("pi/extension-error", (error) => record("extension", error));
     const unsubscribeSession = context.on("pi/session-event", (event) => {
-      const last = event.type === "agent_end" ? event.messages.at(-1) : undefined;
-      if (last?.role === "assistant" && last.stopReason === "error") {
-        record("agent", last.errorMessage ?? "Agent turn failed");
+      const eventType = dataProperty(event, "type").value;
+      if (eventType === "agent_end") {
+        const error = findAgentFailure(event);
+        if (error !== undefined) record("agent", error);
+      }
+      if (eventType === "compaction_end") {
+        const aborted = dataProperty(event, "aborted");
+        const errorMessage = dataProperty(event, "errorMessage");
+        if ((!aborted.accessor && aborted.value === true) || errorMessage.accessor || !errorMessage.value) return;
+        record("compaction", errorMessage.value);
       }
-      if (event.type === "compaction_end" && event.errorMessage) record("compaction", event.errorMessage);
     });
     const disposePanel = context.piPluginUi.register({
       id: "fail-logger-panel",
       pluginId: "@pi-harness/core/plugins/fail-logger",
       title: "Failure Logger",
-      description: "集中记录扩展、Agent 和上下文压缩错误，并去重重复故障。",
+      description: "集中聚合扩展、Agent 和上下文压缩错误，并安全截断诊断内容。",
       icon: "!",
-      read: () => ({ total: failures.length, failures: [...failures].reverse() }),
+      read: () => ({
+        total: failures.length,
+        observed,
+        dropped,
+        capacity: maxFailures,
+        failures: failures
+          .slice()
+          .reverse()
+          .map((failure) => cloneFailure(failure)),
+      }),
     });
     context.effect(() => () => {
       unsubscribeExtension();