@pi-harness/pi-harness 0.1.13 → 0.1.14

package/packages/client-web/test/fail-logger-view.test.ts

@@ -0,0 +1,155 @@
+import { describe, expect, test, vi } from "vitest";
+import { failLoggerPanelView } from "../src/fail-logger-view.js";
+
+describe("failure logger panel view", () => {
+  test("preserves aggregate counters and normalized failure occurrences", () => {
+    const view = failLoggerPanelView({
+      total: 2,
+      observed: 4,
+      dropped: 1,
+      capacity: 50,
+      failures: [
+        { time: "2026-09-05T01:02:03.000Z", source: "agent", message: "failed", occurrences: 3 },
+        { time: "2026-09-05T02:03:04.000Z", source: "compaction", message: "compact failed", occurrences: 1 },
+      ],
+    });
+
+    expect(view).toEqual({
+      total: 2,
+      observed: 4,
+      dropped: 1,
+      capacity: 50,
+      failures: [
+        { time: "2026-09-05T01:02:03.000Z", source: "agent", message: "failed", occurrences: 3 },
+        { time: "2026-09-05T02:03:04.000Z", source: "compaction", message: "compact failed", occurrences: 1 },
+      ],
+      truncated: false,
+    });
+  });
+
+  test("bounds hostile failure lists and strings without trusting invalid counters", () => {
+    const failures = Array.from({ length: 60 }, (_, index) => ({
+      time: index === 0 ? "invalid" : "2026-09-05T00:00:00.000Z",
+      source: "s".repeat(100),
+      message: "m".repeat(3_000),
+      occurrences: index === 1 ? Number.POSITIVE_INFINITY : 1,
+    }));
+    const view = failLoggerPanelView({
+      total: -1,
+      observed: Number.NaN,
+      dropped: -10,
+      capacity: Number.POSITIVE_INFINITY,
+      failures,
+    });
+
+    expect(view.failures).toHaveLength(50);
+    expect(view.failures[0]).toEqual({ time: null, source: "s".repeat(64), message: "m".repeat(2_048), occurrences: 1 });
+    expect(view.failures[1]?.occurrences).toBe(1);
+    expect(view).toMatchObject({ total: 50, observed: 50, dropped: 0, capacity: 50, truncated: true });
+  });
+
+  test("normalizes hostile panel objects without property reads", () => {
+    const reads: PropertyKey[] = [];
+    const hostile = new Proxy(
+      {},
+      {
+        get(_target, key) {
+          reads.push(key);
+          throw new Error(`panel property read: ${String(key)}`);
+        },
+      },
+    );
+
+    expect(() => failLoggerPanelView(hostile)).not.toThrow();
+    expect(reads).toEqual([]);
+    expect(failLoggerPanelView(hostile)).toEqual({
+      total: 0,
+      observed: 0,
+      dropped: 0,
+      capacity: 50,
+      failures: [],
+      truncated: false,
+    });
+  });
+
+  test("normalizes proxy failure arrays without property reads", () => {
+    const reads: PropertyKey[] = [];
+    const failures = new Proxy([{ time: "2026-09-05T01:02:03.000Z", source: "agent", message: "failed", occurrences: 1 }], {
+      get(_target, key) {
+        reads.push(key);
+        throw new Error(`failure list property read: ${String(key)}`);
+      },
+    });
+
+    const view = failLoggerPanelView({ total: 1, observed: 1, dropped: 0, capacity: 50, failures });
+    expect(reads).toEqual([]);
+    expect(view.failures).toEqual([{ time: "2026-09-05T01:02:03.000Z", source: "agent", message: "failed", occurrences: 1 }]);
+    expect(view.truncated).toBe(false);
+  });
+
+  test("normalizes proxy failure records without property reads", () => {
+    const reads: PropertyKey[] = [];
+    const item = new Proxy(
+      { time: "2026-09-05T01:02:03.000Z", source: "agent", message: "failed", occurrences: 2 },
+      {
+        get(_target, key) {
+          reads.push(key);
+          throw new Error(`failure property read: ${String(key)}`);
+        },
+      },
+    );
+
+    const view = failLoggerPanelView({ total: 1, observed: 2, dropped: 0, capacity: 50, failures: [item] });
+    expect(reads).toEqual([]);
+    expect(view.failures).toEqual([{ time: "2026-09-05T01:02:03.000Z", source: "agent", message: "failed", occurrences: 2 }]);
+    expect(view.truncated).toBe(false);
+  });
+
+  test("marks a bounded failure string as truncated even below the list limit", () => {
+    const view = failLoggerPanelView({
+      total: 1,
+      observed: 1,
+      dropped: 0,
+      capacity: 50,
+      failures: [{ time: null, source: "s".repeat(65), message: "m".repeat(2_049), occurrences: 1 }],
+    });
+
+    expect(view.failures[0]).toMatchObject({ source: "s".repeat(64), message: "m".repeat(2_048) });
+    expect(view.truncated).toBe(true);
+  });
+
+  test("sanitizes NUL characters in browser failure strings", () => {
+    const view = failLoggerPanelView({
+      total: 1,
+      observed: 1,
+      dropped: 0,
+      capacity: 50,
+      failures: [{ time: null, source: "ag\0ent", message: "fa\0iled", occurrences: 1 }],
+    });
+
+    expect(view.failures[0]).toMatchObject({ source: "ag�ent", message: "fa�iled" });
+    expect(view.truncated).toBe(true);
+  });
+
+  test("does not trust a capacity above the fixed backend limit", () => {
+    const view = failLoggerPanelView({ total: 0, observed: 0, dropped: 0, capacity: Number.MAX_SAFE_INTEGER, failures: [] });
+    expect(view.capacity).toBe(50);
+  });
+
+  test("rejects oversized timestamps before date parsing", () => {
+    const parse = vi.spyOn(Date, "parse");
+    try {
+      const view = failLoggerPanelView({
+        total: 1,
+        observed: 1,
+        dropped: 0,
+        capacity: 50,
+        failures: [{ time: "2".repeat(10_000), source: "agent", message: "failed", occurrences: 1 }],
+      });
+      expect(view.failures[0]?.time).toBeNull();
+      expect(parse).not.toHaveBeenCalled();
+    } finally {
+      parse.mockRestore();
+    }
+  });
+});

package/packages/client-web/test/genui-view.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, test } from "vitest";
+import { genUiPanelView } from "../src/genui-view.js";
+
+describe("GenUI panel view", () => {
+  test("normalizes a valid structured card and its enforced limits", () => {
+    const view = genUiPanelView({
+      rendered: 3,
+      latest: {
+        title: "Deploy",
+        renderedAt: "2026-09-05T01:02:03.000Z",
+        blocks: [
+          { type: "text", label: "Detail", value: "Plain text", tone: "neutral" },
+          { type: "badge", label: "State", value: "Ready", tone: "success" },
+          { type: "progress", label: "Coverage", value: 87.5, tone: "info" },
+        ],
+      },
+      limits: { blocks: 12, title: 256, label: 256, value: 4_000, totalText: 16_384 },
+    });
+
+    expect(view).toEqual({
+      rendered: 3,
+      latest: {
+        title: "Deploy",
+        renderedAt: "2026-09-05T01:02:03.000Z",
+        blocks: [
+          { type: "text", label: "Detail", value: "Plain text", tone: "neutral" },
+          { type: "badge", label: "State", value: "Ready", tone: "success" },
+          { type: "progress", label: "Coverage", value: 87.5, tone: "info" },
+        ],
+        truncated: false,
+      },
+      limits: { blocks: 12, title: 256, label: 256, value: 4_000, totalText: 16_384 },
+    });
+  });
+
+  test("drops malformed blocks and bounds hostile card details", () => {
+    const blocks = [
+      { type: "text", label: "l".repeat(500), value: "v".repeat(5_000), tone: "neutral" },
+      { type: "progress", label: "bad", value: 200, tone: "danger" },
+      ...Array.from({ length: 15 }, (_, index) => ({ type: "badge", label: `label-${index}`, value: `value-${index}`, tone: "rainbow" })),
+    ];
+    const view = genUiPanelView({
+      rendered: Number.NaN,
+      latest: { title: "t".repeat(500), renderedAt: "invalid", blocks },
+      limits: {},
+    });
+
+    expect(view.rendered).toBe(0);
+    expect(view.latest?.title).toBe("t".repeat(256));
+    expect(view.latest?.renderedAt).toBeNull();
+    expect(view.latest?.blocks).toEqual([{ type: "text", label: "l".repeat(256), value: "v".repeat(2_000), tone: "neutral" }]);
+    expect(view.latest?.truncated).toBe(true);
+    expect(view.limits).toEqual({ blocks: 12, title: 256, label: 256, value: 4_000, totalText: 16_384 });
+  });
+});

package/packages/client-web/test/git-time-capsule-view.test.ts

@@ -0,0 +1,252 @@
+import { describe, expect, test } from "vitest";
+import { gitTimeCapsulePanelView } from "../src/git-time-capsule-view.js";
+
+describe("Git time capsule panel view", () => {
+  test("normalizes activity, capsule inventory, timeout, and safety limits", () => {
+    const view = gitTimeCapsulePanelView({
+      latest: {
+        action: "capture",
+        status: "completed",
+        at: "2026-09-05T06:00:00.000Z",
+        name: "20260905T060000000Z-a1b2c3d4.patch",
+        bytes: 512,
+        files: 2,
+      },
+      capsules: [
+        { name: "20260905T060000000Z-a1b2c3d4.patch", bytes: 512 },
+        { name: "20260905T050000000Z-e5f6a7b8.patch", bytes: 256 },
+      ],
+      inventory: { total: 25, shown: 2, truncated: true, displayLimit: 20 },
+      timeoutMs: 15_000,
+      limits: { capsuleBytes: 8_388_608, inventory: 256, directoryEntries: 4_096 },
+    });
+
+    expect(view).toEqual({
+      latest: {
+        action: "capture",
+        status: "completed",
+        at: "2026-09-05T06:00:00.000Z",
+        name: "20260905T060000000Z-a1b2c3d4.patch",
+        bytes: 512,
+        files: 2,
+        error: null,
+      },
+      capsules: [
+        { name: "20260905T060000000Z-a1b2c3d4.patch", bytes: 512 },
+        { name: "20260905T050000000Z-e5f6a7b8.patch", bytes: 256 },
+      ],
+      inventory: { total: 25, shown: 2, truncated: true, displayLimit: 20 },
+      timeoutMs: 15_000,
+      limits: { capsuleBytes: 8_388_608, inventory: 256, directoryEntries: 4_096 },
+      truncated: false,
+    });
+  });
+
+  test("bounds hostile panel data and never presents malformed activity as success", () => {
+    const capsules = Array.from({ length: 30 }, (_, index) => ({
+      name: index === 0 ? "../outside.patch" : `${String(index).padStart(4, "0")}.patch`,
+      bytes: index === 1 ? Number.POSITIVE_INFINITY : index,
+    }));
+    const view = gitTimeCapsulePanelView({
+      latest: { action: "capture", status: "completed", at: "invalid", name: "../outside.patch", error: "x".repeat(3_000) },
+      capsules,
+      inventory: { total: -1, shown: Number.NaN, truncated: false, displayLimit: Number.POSITIVE_INFINITY },
+      timeoutMs: Number.NaN,
+      limits: { capsuleBytes: -1, inventory: 0, directoryEntries: Number.POSITIVE_INFINITY },
+    });
+
+    expect(view.latest).toBeNull();
+    expect(view.capsules).toHaveLength(18);
+    expect(view.capsules[0]?.name).toBe("0002.patch");
+    expect(view).toMatchObject({
+      inventory: { total: 18, shown: 18, truncated: true, displayLimit: 20 },
+      timeoutMs: 15_000,
+      limits: { capsuleBytes: 8_388_608, inventory: 256, directoryEntries: 4_096 },
+      truncated: true,
+    });
+  });
+
+  test("fails closed without invoking panel accessors or revoked proxies", () => {
+    let getterCalls = 0;
+    const accessor = Object.defineProperty({}, "capsules", {
+      enumerable: true,
+      get() {
+        getterCalls += 1;
+        return [];
+      },
+    });
+    const revocable = Proxy.revocable({}, {});
+    revocable.revoke();
+
+    expect(() => gitTimeCapsulePanelView(accessor)).not.toThrow();
+    expect(() => gitTimeCapsulePanelView(revocable.proxy)).not.toThrow();
+    expect(getterCalls).toBe(0);
+    expect(gitTimeCapsulePanelView(accessor)).toMatchObject({ latest: null, capsules: [], truncated: true });
+    expect(gitTimeCapsulePanelView(revocable.proxy)).toMatchObject({ latest: null, capsules: [], truncated: true });
+  });
+
+  test("bounds inaccessible nested capsule collections without invoking entries", () => {
+    let getterCalls = 0;
+    const accessor = Object.defineProperty({}, "name", {
+      enumerable: true,
+      get() {
+        getterCalls += 1;
+        return "poison.patch";
+      },
+    });
+    const revocable = Proxy.revocable([], {});
+    revocable.revoke();
+
+    expect(() => gitTimeCapsulePanelView({ capsules: revocable.proxy })).not.toThrow();
+    expect(() => gitTimeCapsulePanelView({ capsules: [accessor] })).not.toThrow();
+    expect(getterCalls).toBe(0);
+    expect(gitTimeCapsulePanelView({ capsules: revocable.proxy })).toMatchObject({ capsules: [], truncated: true });
+    expect(gitTimeCapsulePanelView({ capsules: [accessor] })).toMatchObject({ capsules: [], truncated: true });
+  });
+
+  test("removes control and bidi characters from panel-visible failures and names", () => {
+    const view = gitTimeCapsulePanelView({
+      latest: { action: "capture", status: "failed", at: "2026-09-05T06:00:00.000Z", error: "fatal\u202e\u0001message" },
+      capsules: [{ name: "deceptive\u202e.patch", bytes: 1 }],
+      inventory: { total: 1, shown: 1, truncated: false, displayLimit: 20 },
+      timeoutMs: 15_000,
+      limits: { capsuleBytes: 8_388_608, inventory: 256, directoryEntries: 4_096 },
+    });
+
+    expect(view.latest?.error).toBe("fatal message");
+    expect(view.capsules).toEqual([]);
+    expect(view.truncated).toBe(true);
+  });
+
+  test("rejects ambiguous or unsafe capsule names consistently with restore", () => {
+    const view = gitTimeCapsulePanelView({
+      latest: {
+        action: "capture",
+        status: "completed",
+        at: "2026-09-05T06:00:00.000Z",
+        name: " padded.patch ",
+        bytes: 1,
+        files: 1,
+      },
+      capsules: [
+        { name: " padded.patch ", bytes: 1 },
+        { name: `${"😀".repeat(64)}.patch`, bytes: 1 },
+        { name: "broken\ud800.patch", bytes: 1 },
+      ],
+      inventory: { total: 3, shown: 3, truncated: false, displayLimit: 20 },
+      timeoutMs: 15_000,
+      limits: { capsuleBytes: 8_388_608, inventory: 256, directoryEntries: 4_096 },
+    });
+
+    expect(view.latest).toBeNull();
+    expect(view.capsules).toEqual([]);
+    expect(view.truncated).toBe(true);
+  });
+
+  test("replaces contradictory inventory and limit metadata with safe contract values", () => {
+    const view = gitTimeCapsulePanelView({
+      latest: null,
+      capsules: [{ name: "20260905T060000000Z-a1b2c3d4.patch", bytes: 512 }],
+      inventory: { total: 0, shown: 20, truncated: false, displayLimit: 999 },
+      timeoutMs: 999_999,
+      limits: { capsuleBytes: 1, inventory: 999, directoryEntries: 1 },
+    });
+
+    expect(view).toMatchObject({
+      capsules: [{ name: "20260905T060000000Z-a1b2c3d4.patch", bytes: 512 }],
+      inventory: { total: 1, shown: 1, truncated: true, displayLimit: 20 },
+      timeoutMs: 15_000,
+      limits: { capsuleBytes: 8_388_608, inventory: 256, directoryEntries: 4_096 },
+      truncated: true,
+    });
+  });
+
+  test("rejects activity and inventory byte counts beyond the capsule limit", () => {
+    const name = "20260905T060000000Z-a1b2c3d4.patch";
+    const view = gitTimeCapsulePanelView({
+      latest: { action: "capture", status: "completed", at: "2026-09-05T06:00:00.000Z", name, bytes: 8_388_609, files: 1 },
+      capsules: [{ name, bytes: 8_388_609 }],
+      inventory: { total: 1, shown: 1, truncated: false, displayLimit: 20 },
+      timeoutMs: 15_000,
+      limits: { capsuleBytes: 8_388_608, inventory: 256, directoryEntries: 4_096 },
+    });
+
+    expect(view.latest).toBeNull();
+    expect(view.capsules).toEqual([]);
+    expect(view.truncated).toBe(true);
+  });
+
+  test("rejects failure activity that omits its diagnostic", () => {
+    const view = gitTimeCapsulePanelView({
+      latest: { action: "restore", status: "failed", at: "2026-09-05T06:00:00.000Z" },
+      capsules: [],
+      inventory: { total: 0, shown: 0, truncated: false, displayLimit: 20 },
+      timeoutMs: 15_000,
+      limits: { capsuleBytes: 8_388_608, inventory: 256, directoryEntries: 4_096 },
+    });
+
+    expect(view.latest).toBeNull();
+    expect(view.truncated).toBe(true);
+  });
+
+  test("rejects non-canonical activity timestamps instead of silently rewriting them", () => {
+    const name = "20260905T060000000Z-a1b2c3d4.patch";
+    const view = gitTimeCapsulePanelView({
+      latest: { action: "capture", status: "completed", at: "2026-09-05T06:00:00Z", name, bytes: 512, files: 2 },
+      capsules: [{ name, bytes: 512 }],
+      inventory: { total: 1, shown: 1, truncated: false, displayLimit: 20 },
+      timeoutMs: 15_000,
+      limits: { capsuleBytes: 8_388_608, inventory: 256, directoryEntries: 4_096 },
+    });
+
+    expect(view.latest).toBeNull();
+    expect(view.truncated).toBe(true);
+  });
+
+  test("marks unknown top-level panel contract fields as truncated", () => {
+    const view = gitTimeCapsulePanelView({
+      latest: null,
+      capsules: [],
+      inventory: { total: 0, shown: 0, truncated: false, displayLimit: 20 },
+      timeoutMs: 15_000,
+      limits: { capsuleBytes: 8_388_608, inventory: 256, directoryEntries: 4_096 },
+      unexpected: true,
+    });
+
+    expect(view).toMatchObject({ latest: null, capsules: [], truncated: true });
+  });
+
+  test("marks unknown nested panel contract fields as truncated", () => {
+    const name = "20260905T060000000Z-a1b2c3d4.patch";
+    const base = {
+      latest: { action: "capture", status: "completed", at: "2026-09-05T06:00:00.000Z", name, bytes: 512, files: 2 },
+      capsules: [{ name, bytes: 512 }],
+      inventory: { total: 1, shown: 1, truncated: false, displayLimit: 20 },
+      timeoutMs: 15_000,
+      limits: { capsuleBytes: 8_388_608, inventory: 256, directoryEntries: 4_096 },
+    };
+
+    const views = [
+      gitTimeCapsulePanelView({ ...base, latest: { ...base.latest, unexpected: true } }),
+      gitTimeCapsulePanelView({ ...base, capsules: [{ ...base.capsules[0], unexpected: true }] }),
+      gitTimeCapsulePanelView({ ...base, inventory: { ...base.inventory, unexpected: true } }),
+      gitTimeCapsulePanelView({ ...base, limits: { ...base.limits, unexpected: true } }),
+    ];
+
+    expect(views.map((view) => view.truncated)).toEqual([true, true, true, true]);
+    expect(views.every((view) => view.capsules.length === 1 && view.inventory.total === 1)).toBe(true);
+  });
+
+  test("accepts the restore completion marker emitted by the backend", () => {
+    const name = "20260905T060000000Z-a1b2c3d4.patch";
+    const view = gitTimeCapsulePanelView({
+      latest: { action: "restore", status: "completed", at: "2026-09-05T06:00:00.000Z", name, bytes: 512, files: 2, restored: true },
+      capsules: [{ name, bytes: 512 }],
+      inventory: { total: 1, shown: 1, truncated: false, displayLimit: 20 },
+      timeoutMs: 15_000,
+      limits: { capsuleBytes: 8_388_608, inventory: 256, directoryEntries: 4_096 },
+    });
+
+    expect(view).toMatchObject({ latest: { action: "restore", status: "completed", name }, truncated: false });
+  });
+});

package/packages/client-web/test/graph-memory-view.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, test } from "vitest";
+import { graphMemoryPanelView } from "../src/graph-memory-view.js";
+
+describe("Graph memory panel view", () => {
+  test("normalizes graph counts, recent nodes, relations, search, and limits", () => {
+    const view = graphMemoryPanelView({
+      nodes: 2,
+      relations: 1,
+      kinds: { task: 1, skill: 1, event: 0 },
+      recent: [
+        {
+          id: "node-1",
+          kind: "task",
+          label: "Ship",
+          summary: "Run verification",
+          source: "release",
+          createdAt: "2026-09-05T00:00:00.000Z",
+          updatedAt: "2026-09-05T01:00:00.000Z",
+        },
+      ],
+      recentRelations: [
+        { id: "rel-1", from: "node-1", to: "node-2", relation: "USED_SKILL", createdAt: "2026-09-05T01:00:00.000Z", fromLabel: "Ship", toLabel: "Verify" },
+      ],
+      lastSearch: { query: "verify", total: 2, nodes: [{ id: "node-1" }], relations: [] },
+      limits: { nodes: 2_000, relations: 5_000, fileBytes: 4_194_304, searchResults: 50 },
+    });
+
+    expect(view).toMatchObject({
+      nodes: 2,
+      relations: 1,
+      kinds: { task: 1, skill: 1, event: 0 },
+      recent: [{ id: "node-1", kind: "task", label: "Ship", summary: "Run verification", source: "release", updatedAt: "2026-09-05T01:00:00.000Z" }],
+      recentRelations: [{ relation: "USED_SKILL", fromLabel: "Ship", toLabel: "Verify" }],
+      lastSearch: { query: "verify", total: 2, shown: 1 },
+      limits: { nodes: 2_000, relations: 5_000, fileBytes: 4_194_304, searchResults: 50 },
+      truncated: false,
+    });
+  });
+
+  test("bounds hostile graph arrays and strings while rejecting malformed entries", () => {
+    const recent = Array.from({ length: 12 }, (_, index) => ({
+      id: `node-${index}`,
+      kind: index === 0 ? "invalid" : "event",
+      label: "l".repeat(300),
+      summary: "s".repeat(5_000),
+      source: "p".repeat(1_000),
+      createdAt: "invalid",
+      updatedAt: "invalid",
+    }));
+    const view = graphMemoryPanelView({
+      nodes: -1,
+      relations: Number.NaN,
+      kinds: { task: -1 },
+      recent,
+      recentRelations: [{}],
+      lastSearch: { query: "q".repeat(300), total: -1, nodes: new Array(100) },
+      limits: {},
+    });
+
+    expect(view.nodes).toBe(7);
+    expect(view.recent).toHaveLength(7);
+    expect(view.recent[0]).toMatchObject({ label: "l".repeat(160), summary: "s".repeat(2_000), source: "p".repeat(512), updatedAt: null });
+    expect(view.recentRelations).toEqual([]);
+    expect(view.lastSearch).toEqual({ query: "q".repeat(160), total: 50, shown: 50 });
+    expect(view.truncated).toBe(true);
+  });
+});

package/packages/client-web/test/i18n-pair-panel.test.ts

@@ -0,0 +1,72 @@
+import { createElement } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import { describe, expect, test } from "vitest";
+import { PluginPanelCard } from "../src/react-room.js";
+
+function renderPanel(data: unknown): string {
+  return renderToStaticMarkup(
+    createElement(PluginPanelCard, {
+      panel: {
+        id: "i18n-pair-panel",
+        pluginId: "@pi-harness/core/plugins/i18n-pair",
+        title: "I18n Pair",
+        data,
+      },
+    }),
+  );
+}
+
+function complete(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    status: { state: "completed", at: "2026-09-05T01:00:00.000Z" },
+    report: {
+      base: "locales/en.json",
+      target: "locales/ja.json",
+      baseKeys: 3,
+      targetKeys: 2,
+      missing: ["actions.cancel"],
+      extra: [],
+      missingTotal: 1,
+      extraTotal: 0,
+      truncated: false,
+    },
+    limits: { fileBytes: 4_194_304, depth: 128, keysPerFile: 50_000, flattenedKeyLength: 2_048, pathLength: 4_096, panelKeysPerSide: 100 },
+    ...overrides,
+  };
+}
+
+describe("I18n pair panel", () => {
+  test("renders validated parity counts, paths, keys, status, and limits", () => {
+    const html = renderPanel(complete());
+
+    for (const expected of ["已完成", "缺失 1 个，额外 0 个", "locales/en.json", "locales/ja.json", "actions.cancel", "file:4MiB", "depth:128", "keys:50000"])
+      expect(html).toContain(expected);
+    expect(html).not.toContain("面板数据不完整或不可信");
+  });
+
+  test("retains the last valid report while showing a later failure", () => {
+    const html = renderPanel(complete({ status: { state: "failed", at: "2026-09-05T01:01:00.000Z", error: "Invalid locale JSON" } }));
+
+    expect(html).toContain("检查失败");
+    expect(html).toContain("Invalid locale JSON");
+    expect(html).toContain("actions.cancel");
+  });
+
+  test("fails closed for malformed data without manufacturing success counts", () => {
+    const html = renderPanel(complete({ report: { baseKeys: 0, targetKeys: 0, missing: [], extra: [] } }));
+
+    expect(html).toContain("数据异常");
+    expect(html).toContain("面板数据不完整或不可信");
+    expect(html).not.toContain("语言包键完全一致");
+    expect(html).not.toContain("基准键");
+    expect(html).not.toContain("目标键");
+  });
+
+  test("renders a useful untouched state", () => {
+    const html = renderPanel(complete({ status: { state: "idle" }, report: null }));
+
+    expect(html).toContain("等待检查");
+    expect(html).toContain("还没有检查语言包");
+    expect(html).toContain("i18n_check");
+  });
+});