@selesai/code 0.12.0 → 0.13.1

package/dist/extensions/pi-hermes-memory/tests/tools/session-search-tool.test.ts

@@ -0,0 +1,345 @@
+import { describe, it, afterEach } from "node:test";
+import * as assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { registerSessionSearchTool } from "../../src/tools/session-search-tool.js";
+import { DatabaseManager } from "../../src/store/db.js";
+import { indexSession } from "../../src/store/session-indexer.js";
+
+let ROOT_DIR = "";
+
+afterEach(() => {
+  if (ROOT_DIR) fs.rmSync(ROOT_DIR, { recursive: true, force: true });
+  ROOT_DIR = "";
+});
+
+function makeSessionsDir(): string {
+  ROOT_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "pi-session-search-tool-test-"));
+  return ROOT_DIR;
+}
+
+describe("registerSessionSearchTool", () => {
+  it("registers the legacy query schema by default", () => {
+    let captured: any;
+    const mockPi = {
+      registerTool: (def: any) => { captured = def; },
+    } as any;
+
+    registerSessionSearchTool(mockPi, {} as any);
+
+    const schema = JSON.stringify(captured.parameters);
+    assert.strictEqual(captured.name, "session_search");
+    assert.match(schema, /query/);
+    assert.doesNotMatch(schema, /markdown/);
+    assert.match(schema, /"minimum":1/);
+    assert.match(schema, /"maximum":20/);
+  });
+
+  it("clamps negative and fractional legacy limits before querying", async () => {
+    let captured: any;
+    const mockPi = {
+      registerTool: (def: any) => { captured = def; },
+    } as any;
+    const memoryDir = makeSessionsDir();
+    const dbManager = new DatabaseManager(memoryDir);
+
+    try {
+      indexSession(dbManager, {
+        id: "bounded-limit-session",
+        project: "bounded-project",
+        cwd: "/work/bounded",
+        startedAt: "2026-07-11T00:00:00.000Z",
+        endedAt: null,
+        messages: Array.from({ length: 25 }, (_, index) => ({
+          id: `bounded-limit-message-${index}`,
+          role: "assistant",
+          content: `bounded-limit-needle ${index}`,
+          timestamp: `2026-07-11T00:${String(index).padStart(2, "0")}:00.000Z`,
+        })),
+      });
+      registerSessionSearchTool(mockPi, dbManager);
+
+      const negative = await captured.execute("tc-negative-limit", {
+        query: "bounded-limit-needle",
+        limit: -1,
+      });
+      const fractional = await captured.execute("tc-fractional-limit", {
+        query: "bounded-limit-needle",
+        limit: 2.9,
+      });
+
+      assert.strictEqual(negative.details.count, 1);
+      assert.strictEqual(fractional.details.count, 2);
+      assert.ok(negative.content[0].text.length < 2_000);
+      assert.ok(fractional.content[0].text.length < 4_000);
+    } finally {
+      dbManager.close();
+    }
+  });
+
+  it("clamps non-finite snippetChars values instead of propagating NaN", async () => {
+    let captured: any;
+    const mockPi = {
+      registerTool: (def: any) => { captured = def; },
+    } as any;
+    const memoryDir = makeSessionsDir();
+    const dbManager = new DatabaseManager(memoryDir);
+
+    try {
+      indexSession(dbManager, {
+        id: "nan-snippet-session",
+        project: "nan-snippet-project",
+        cwd: "/work/nan-snippet",
+        startedAt: "2026-07-11T00:00:00.000Z",
+        endedAt: null,
+        messages: [{
+          id: "nan-snippet-message",
+          role: "assistant",
+          content: `needle ${"a".repeat(500)}`,
+          timestamp: "2026-07-11T00:01:00.000Z",
+        }],
+      });
+      registerSessionSearchTool(mockPi, dbManager);
+
+      const nanResult = await captured.execute("tc-nan-snippet", {
+        query: "needle",
+        snippetChars: NaN,
+      });
+      const infinityResult = await captured.execute("tc-infinity-snippet", {
+        query: "needle",
+        snippetChars: Infinity,
+      });
+      const largeResult = await captured.execute("tc-large-snippet", {
+        query: "needle",
+        snippetChars: 999_999_999,
+      });
+
+      assert.strictEqual(nanResult.details.snippetChars, 1_200);
+      assert.strictEqual(infinityResult.details.snippetChars, 1_200);
+      assert.strictEqual(largeResult.details.snippetChars, 4_000);
+      assert.ok(Number.isFinite(nanResult.details.snippetChars));
+      assert.match(nanResult.content[0].text, /needle a+/);
+    } finally {
+      dbManager.close();
+    }
+  });
+
+  it("bounds oversized legacy results and reports truncation without duplicating output in details", async () => {
+    let captured: any;
+    const mockPi = {
+      registerTool: (def: any) => { captured = def; },
+    } as any;
+    const memoryDir = makeSessionsDir();
+    const dbManager = new DatabaseManager(memoryDir);
+    const oversizedContent = `needle ${"x".repeat(6_000_000)}`;
+
+    try {
+      // Seed a pre-cap database row directly. New ingestion paths must cap
+      // message content, but search output still needs to stay bounded for
+      // oversized rows written by older extension versions.
+      const db = dbManager.getDb();
+      db.prepare(`
+        INSERT INTO sessions (id, project, cwd, started_at, ended_at, message_count)
+        VALUES (?, ?, ?, ?, ?, ?)
+      `).run(
+        "oversized-session",
+        "oversized-project",
+        "/work/oversized",
+        "2026-07-11T00:00:00.000Z",
+        null,
+        1,
+      );
+      db.prepare(`
+        INSERT INTO messages (id, session_id, role, content, timestamp)
+        VALUES (?, ?, ?, ?, ?)
+      `).run(
+        "oversized-message",
+        "oversized-session",
+        "assistant",
+        oversizedContent,
+        "2026-07-11T00:01:00.000Z",
+      );
+      registerSessionSearchTool(mockPi, dbManager);
+
+      const result = await captured.execute("tc-oversized", { query: "needle" });
+      const output = result.content[0].text as string;
+
+      assert.ok(output.length <= 50 * 1024, `expected <= 50 KiB, got ${output.length}`);
+      assert.match(output, /truncated/);
+      assert.match(output, /6000007 chars total/);
+      assert.strictEqual(result.details.truncatedCount, 1);
+      assert.strictEqual(result.details.outputChars, output.length);
+      assert.strictEqual(result.details.output, undefined);
+      assert.ok(JSON.stringify(result.details).length < 1_000);
+    } finally {
+      dbManager.close();
+    }
+  });
+
+  it("offers a bounded snippetChars override for legacy searches", async () => {
+    let captured: any;
+    const mockPi = {
+      registerTool: (def: any) => { captured = def; },
+    } as any;
+    const memoryDir = makeSessionsDir();
+    const dbManager = new DatabaseManager(memoryDir);
+
+    try {
+      indexSession(dbManager, {
+        id: "bounded-override-session",
+        project: "bounded-project",
+        cwd: "/work/bounded",
+        startedAt: "2026-07-11T00:00:00.000Z",
+        endedAt: null,
+        messages: [{
+          id: "bounded-override-message",
+          role: "assistant",
+          content: `needle ${"y".repeat(10_000)}`,
+          timestamp: "2026-07-11T00:01:00.000Z",
+        }],
+      });
+      registerSessionSearchTool(mockPi, dbManager);
+
+      assert.match(JSON.stringify(captured.parameters), /snippetChars/);
+      const result = await captured.execute("tc-bounded-override", {
+        query: "needle",
+        snippetChars: 2_000,
+      });
+
+      assert.strictEqual(result.details.snippetChars, 2_000);
+      assert.strictEqual(result.details.truncatedCount, 1);
+      assert.match(result.content[0].text, /10007 chars total/);
+      assert.ok(result.content[0].text.length < 3_000);
+    } finally {
+      dbManager.close();
+    }
+  });
+
+  it("enforces a hard 50 KiB ceiling across many large legacy results", async () => {
+    let captured: any;
+    const mockPi = {
+      registerTool: (def: any) => { captured = def; },
+    } as any;
+    const memoryDir = makeSessionsDir();
+    const dbManager = new DatabaseManager(memoryDir);
+
+    try {
+      indexSession(dbManager, {
+        id: "aggregate-ceiling-session",
+        project: "aggregate-project",
+        cwd: "/work/aggregate",
+        startedAt: "2026-07-11T00:00:00.000Z",
+        endedAt: null,
+        messages: Array.from({ length: 20 }, (_, index) => ({
+          id: `aggregate-message-${index}`,
+          role: "assistant",
+          content: `needle-${index} ${"z".repeat(10_000)}`,
+          timestamp: `2026-07-11T00:${String(index).padStart(2, "0")}:00.000Z`,
+        })),
+      });
+      registerSessionSearchTool(mockPi, dbManager);
+
+      const result = await captured.execute("tc-aggregate-ceiling", {
+        query: "needle",
+        limit: 20,
+        snippetChars: 4_000,
+      });
+      const output = result.content[0].text as string;
+
+      assert.ok(output.length <= 50 * 1024, `expected <= 50 KiB, got ${output.length}`);
+      assert.strictEqual(result.details.outputTruncated, true);
+      assert.match(output, /output truncated/);
+      assert.match(output, /refine the query or lower the result limit/);
+    } finally {
+      dbManager.close();
+    }
+  });
+
+  it("bounds the zero-result response without echoing an oversized query", async () => {
+    let captured: any;
+    const mockPi = {
+      registerTool: (def: any) => { captured = def; },
+    } as any;
+    const memoryDir = makeSessionsDir();
+    const dbManager = new DatabaseManager(memoryDir);
+
+    try {
+      indexSession(dbManager, {
+        id: "zero-result-session",
+        project: "zero-result-project",
+        cwd: "/work/zero-result",
+        startedAt: "2026-07-11T00:00:00.000Z",
+        endedAt: null,
+        messages: [{
+          id: "zero-result-message",
+          role: "assistant",
+          content: "indexed haystack",
+          timestamp: "2026-07-11T00:01:00.000Z",
+        }],
+      });
+      registerSessionSearchTool(mockPi, dbManager);
+      const query = `${" ".repeat(60_000)}missing`;
+
+      const result = await captured.execute("tc-zero-result", { query });
+      const output = result.content[0].text as string;
+
+      assert.strictEqual(result.details.count, 0);
+      assert.ok(output.length <= 50 * 1024, `expected <= 50 KiB, got ${output.length}`);
+      assert.strictEqual(output.includes(query), false);
+      assert.ok(JSON.stringify(result.details).length < 1_000);
+    } finally {
+      dbManager.close();
+    }
+  });
+
+  it("registers and executes the anchor markdown-only schema when configured", async () => {
+    let captured: any;
+    const mockPi = {
+      registerTool: (def: any) => { captured = def; },
+    } as any;
+    const sessionsDir = makeSessionsDir();
+    const filePath = path.join(sessionsDir, "session.jsonl");
+    fs.writeFileSync(filePath, `${JSON.stringify({
+      type: "message",
+      timestamp: "2026-05-15T10:00:00.000Z",
+      sessionId: "session-1",
+      cwd: "/work/project",
+      message: { role: "user", content: "needle" },
+    })}\n`);
+
+    registerSessionSearchTool(mockPi, {} as any, { variant: "anchors" }, { sessionsDir });
+
+    const schema = JSON.stringify(captured.parameters);
+    assert.strictEqual(captured.name, "session_search");
+    assert.match(schema, /markdown/);
+    assert.doesNotMatch(schema, /query/);
+    assert.match(captured.description, /all terms must match/);
+    assert.match(captured.description, /any requires at least one listed term/);
+    assert.match(captured.description, /exclude removes matching ranges/);
+    assert.match(captured.description, /Output is plain text: count, optional message/);
+    assert.match(captured.description, /path:startLine-endLine with a short reason/);
+    assert.match(captured.description, /Example:\nfrom: 2026-05-14/);
+    assert.match(captured.promptGuidelines.join("\n"), /Use all for required terms/);
+
+    const empty = await captured.execute("tc-1", { markdown: "" });
+    assert.strictEqual(empty.details.success, false);
+    assert.strictEqual(empty.details.message, "markdown is required");
+
+    const result = await captured.execute("tc-2", { markdown: "any:\n- needle" });
+    assert.strictEqual(result.details.success, true);
+    assert.strictEqual(result.details.count, 1);
+    assert.deepStrictEqual(result.details.ranges.map((range: any) => ({
+      path: range.path,
+      startLine: range.startLine,
+      endLine: range.endLine,
+      reason: range.reason,
+    })), [{ path: filePath, startLine: 1, endLine: 1, reason: "matched any: needle" }]);
+    assert.strictEqual(result.details.output, result.content[0].text);
+    assert.match(result.content[0].text, /^count: 1\nanchors:\n-/);
+    assert.match(result.content[0].text, new RegExp(`${filePath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}:1-1 — matched any: needle`));
+    assert.doesNotMatch(result.content[0].text, /"ranges"/);
+    assert.doesNotMatch(result.content[0].text, /"startLine"/);
+    assert.doesNotMatch(result.content[0].text, /"sessionId"/);
+  });
+});

package/dist/extensions/pi-hermes-memory/tests/tools/shared-output-view.test.ts

@@ -0,0 +1,362 @@
+import { describe, it } from "node:test";
+import * as assert from "node:assert/strict";
+import { initTheme } from "@earendil-works/pi-coding-agent";
+import { Box, visibleWidth, type Component } from "@earendil-works/pi-tui";
+import {
+  createSharedToolResultRenderer,
+  type SharedOutputView,
+} from "../../src/tools/shared-output-view.js";
+import {
+  memoryResultView,
+  searchResultView,
+  skillResultView,
+} from "../../src/tools/tool-result-views.js";
+
+initTheme();
+
+function fakeTheme() {
+  return {
+    fg: (_color: string, text: string): string => text,
+    getBgAnsi: (_color: string): string => "",
+  } as any;
+}
+
+function stripAnsi(text: string): string {
+  return text.replace(/\x1b\[[0-?]*[ -/]*m/g, "");
+}
+
+function renderPlain(component: Component, width = 120): string {
+  return component.render(width).map((row) => stripAnsi(row).trimEnd()).join("\n");
+}
+
+function result(text: string, details: Record<string, unknown> = { success: true }) {
+  return { content: [{ type: "text", text }], details };
+}
+
+function renderToolResult(
+  toolResult: ReturnType<typeof result>,
+  expanded: boolean,
+  width = 120,
+): string {
+  return renderPlain(
+    createSharedToolResultRenderer()(
+      toolResult,
+      { expanded, isPartial: false },
+      fakeTheme(),
+      { isError: false },
+    ),
+    width,
+  );
+}
+
+function renderView(view: SharedOutputView, expanded: boolean, width = 120): string {
+  return renderPlain(
+    createSharedToolResultRenderer(() => view)(
+      result(view.expandedText),
+      { expanded, isPartial: false },
+      fakeTheme(),
+      { isError: false },
+    ),
+    width,
+  );
+}
+
+function assertRowKeepsBackground(row: string): void {
+  let backgroundActive = false;
+  for (let index = 0; index < row.length;) {
+    const sgr = row.slice(index).match(/^\x1b\[([0-9;]*)m/);
+    if (sgr) {
+      const parameters = sgr[1];
+      if (parameters === "" || parameters === "0" || parameters === "49") {
+        backgroundActive = false;
+      } else if (parameters.split(";")[0] === "48") {
+        backgroundActive = true;
+      }
+      index += sgr[0].length;
+      continue;
+    }
+    assert.equal(backgroundActive, true, `background cleared before ${JSON.stringify(row.slice(index))}`);
+    index += 1;
+  }
+}
+
+describe("shared tool-result view", () => {
+  it("collapses to one concise line and expands to the full bounded result", () => {
+    const toolResult = result("Found 2 memories matching auth:\n\nfirst\nsecond", {
+      success: true,
+      count: 2,
+    });
+
+    const collapsed = renderToolResult(toolResult, false);
+    assert.equal(collapsed.split("\n").length, 1);
+    assert.match(collapsed, /Found 2 memories matching auth/);
+    assert.doesNotMatch(collapsed, /second/);
+    assert.match(collapsed, /expand/);
+
+    const expanded = renderToolResult(toolResult, true);
+    assert.equal(expanded, toolResult.content[0].text);
+  });
+
+  it("sanitizes only the rendered copy of hostile tool text and failure details", () => {
+    const hostileText = [
+      "safe 世界 \x1b]52;c;YXR0YWNr\x07 after OSC",
+      "styled \x1b[31mred\x1b[0m moved \x1b[2J after CSI",
+      "private \x1bPdanger\x1b\\ after DCS",
+      "linked \x1b]8;;https://evil.example\x1b\\label\x1b]8;;\x1b\\ after ST",
+      "carriage\rreturn binary\x00\x08\x7f end",
+    ].join("\n");
+    const hostileReason = "query \x1b]52;c;YXR0YWNr\x07 is required\x00";
+    const toolResult = result(hostileText, {
+      success: false,
+      message: hostileReason,
+      nested: { keep: true },
+    });
+    const before = structuredClone(toolResult);
+
+    const collapsed = renderToolResult(toolResult, false);
+    const expanded = renderToolResult(toolResult, true);
+
+    for (const rendered of [collapsed, expanded]) {
+      assert.doesNotMatch(rendered, /\x1b|\x07|\x00|\x08|\x7f|\r/);
+    }
+    assert.match(collapsed, /query .* is required/);
+    assert.match(expanded, /safe 世界/);
+    assert.match(expanded, /styled red moved  after CSI/);
+    assert.match(expanded, /private danger\\ after DCS/);
+    assert.match(expanded, /linked label after ST/);
+    assert.match(expanded, /carriagereturn binary end/);
+    assert.deepEqual(toolResult, before);
+
+    const adapterResult = result("safe", {
+      success: true,
+      message: "Entry added.",
+      target: "memory\x1b[2J",
+      usage: "1 entry\x00",
+    });
+    const adapterBefore = structuredClone(adapterResult);
+    const adapterRendered = renderPlain(createSharedToolResultRenderer(memoryResultView)(
+      adapterResult,
+      { expanded: false, isPartial: false },
+      fakeTheme(),
+      { isError: false },
+    ));
+    assert.doesNotMatch(adapterRendered, /\x1b|\x00/);
+    assert.deepEqual(adapterResult, adapterBefore);
+  });
+
+  it("does not mutate model-visible content or details", () => {
+    const toolResult = result("immutable\nfull output", {
+      success: true,
+      nested: { keep: true },
+    });
+    const before = structuredClone(toolResult);
+
+    renderToolResult(toolResult, false);
+    renderToolResult(toolResult, true);
+
+    assert.deepEqual(toolResult, before);
+  });
+
+  it("keeps textual failure and warning reasons in collapsed output", () => {
+    const failure = renderToolResult(
+      result("query is required", { success: false, message: "query is required" }),
+      false,
+    );
+    assert.match(failure, /query is required/);
+
+    const warningView = memoryResultView(result(JSON.stringify({
+      success: true,
+      message: "Entry added. Warning: SQLite mirror unavailable",
+      warning: "SQLite mirror unavailable",
+      warnings: ["SQLite mirror unavailable"],
+      target: "memory",
+      entry_count: 1,
+    }), {
+      success: true,
+      message: "Entry added. Warning: SQLite mirror unavailable",
+      warning: "SQLite mirror unavailable",
+      warnings: ["SQLite mirror unavailable"],
+      target: "memory",
+      entry_count: 1,
+    }));
+    assert.match(renderView(warningView, false), /SQLite mirror unavailable/);
+  });
+
+  it("fits ANSI, CJK, and partial rows while preserving the outer tool-card background", () => {
+    const width = 34;
+    const backgroundOpen = "\x1b[48;2;40;50;40m";
+    const ansiTheme = {
+      fg: (_color: string, text: string): string => `\x1b[38;2;145;148;145m${text}\x1b[39m`,
+      getBgAnsi: (_color: string): string => backgroundOpen,
+    } as any;
+    const box = new Box(1, 1, (text: string) => `${backgroundOpen}${text}\x1b[49m`);
+    box.addChild(createSharedToolResultRenderer()(
+      result("处理中 世界世界世界世界 \x1b[1mvery long partial output\x1b[0m"),
+      { expanded: false, isPartial: true },
+      ansiTheme,
+      { isError: false },
+    ));
+
+    const rows = box.render(width);
+    assert.equal(rows.length, 3);
+    assert.equal(visibleWidth(rows[1]), width);
+    assert.match(stripAnsi(rows[1]), /处理中|In progress/);
+
+    assertRowKeepsBackground(rows[1]);
+  });
+
+  it("keeps the tool-card background after sanitizing expanded ANSI and CJK text", () => {
+    const width = 18;
+    const backgroundOpen = "\x1b[48;2;40;50;40m";
+    const ansiTheme = {
+      fg: (_color: string, text: string): string => text,
+      getBgAnsi: (_color: string): string => backgroundOpen,
+    } as any;
+    const expandedText = "第一行 世界世界世界\x1b[0m继续\n第二行 \x1b[49m背景保留";
+    const box = new Box(1, 1, (text: string) => `${backgroundOpen}${text}\x1b[49m`);
+    box.addChild(createSharedToolResultRenderer()(
+      result(expandedText),
+      { expanded: true, isPartial: false },
+      ansiTheme,
+      { isError: false },
+    ));
+
+    const rows = box.render(width);
+    assert.ok(rows.length > 4);
+    for (const row of rows) {
+      assert.equal(visibleWidth(row), width);
+      assertRowKeepsBackground(row);
+    }
+    const expandedRows = rows.slice(1, -1).map((row) => stripAnsi(row).trim());
+    assert.deepEqual(expandedRows, ["第一行 世界世界", "世界继续", "第二行 背景保留"]);
+  });
+
+  it("uses Pi shell state for the card background and logical status for foreground", () => {
+    const scenarios = [
+      { partial: true, isError: false, success: false, background: "toolPendingBg", foreground: "warning" },
+      { partial: false, isError: true, success: true, background: "toolErrorBg", foreground: "error" },
+      { partial: false, isError: false, success: true, background: "toolSuccessBg", foreground: "toolOutput" },
+      { partial: false, isError: false, success: false, background: "toolSuccessBg", foreground: "error" },
+    ] as const;
+
+    for (const scenario of scenarios) {
+      const backgrounds: string[] = [];
+      const foregrounds: string[] = [];
+      const theme = {
+        fg: (color: string, text: string): string => {
+          foregrounds.push(color);
+          return text;
+        },
+        getBgAnsi: (color: string): string => {
+          backgrounds.push(color);
+          return "";
+        },
+      } as any;
+      const message = scenario.success ? "done" : "query is required";
+      const toolResult = result(message, { success: scenario.success, message });
+
+      const renderer = createSharedToolResultRenderer();
+      const rendered = renderPlain(renderer(
+        toolResult,
+        { expanded: false, isPartial: scenario.partial },
+        theme,
+        { isError: scenario.isError },
+      ));
+      renderPlain(renderer(
+        toolResult,
+        { expanded: true, isPartial: scenario.partial },
+        theme,
+        { isError: scenario.isError },
+      ));
+
+      assert.deepEqual(backgrounds, [scenario.background, scenario.background]);
+      assert.deepEqual(foregrounds, [scenario.foreground]);
+      if (!scenario.success) assert.match(rendered, /query is required/);
+    }
+  });
+});
+
+describe("tool-specific summaries", () => {
+  it("summarizes memory, search/session, and skill results without changing expanded text", () => {
+    const memoryText = JSON.stringify({
+      success: true,
+      message: "Entry added.",
+      target: "failure",
+      category: "tool-quirk",
+      entry_count: 2,
+      usage: "120 / 5,000 chars",
+    });
+    const memory = memoryResultView(result(memoryText, JSON.parse(memoryText)));
+    assert.match(memory.summary, /Saved/);
+    assert.match(memory.summary, /target: failure/);
+    assert.match(memory.summary, /category: tool-quirk/);
+    assert.equal(memory.expandedText, memoryText);
+
+    const searchText = "Found 3 memories matching auth:\n\nfirst\nsecond\nthird";
+    const search = searchResultView(result(searchText, { success: true, count: 3 }));
+    assert.match(search.summary, /3/);
+    assert.equal(search.expandedText, searchText);
+
+    const skillText = JSON.stringify({ success: true, skillId: "global:deploy", name: "deploy" });
+    const skill = skillResultView(result(skillText, JSON.parse(skillText)));
+    assert.match(skill.summary, /deploy/i);
+    assert.equal(skill.expandedText, skillText);
+  });
+
+  it("renders a real skill-tool JSON failure as an actionable failure", () => {
+    const error = "Skill 'global:missing' not found.";
+    const skillText = JSON.stringify({ success: false, error });
+    const toolResult = result(skillText, {});
+    const skill = skillResultView(toolResult);
+
+    assert.equal(skill.status, "failure");
+    assert.equal(skill.summary, `Error · ${error}`);
+    assert.equal(skill.expandedText, skillText);
+    assert.match(renderPlain(
+      createSharedToolResultRenderer(skillResultView)(
+        toolResult,
+        { expanded: false, isPartial: false },
+        fakeTheme(),
+        { isError: false },
+      ),
+    ), new RegExp(error.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")));
+  });
+
+  it("summarizes successful failure memory from the real producer result shape", () => {
+    // MemoryResult has no category field; producers encode it only in message.
+    const details = {
+      success: true,
+      target: "failure",
+      message: "Failure memory saved: tool-quirk",
+      entry_count: 16,
+      usage: "92% — 9271/10000 chars",
+    };
+    const fullText = JSON.stringify(details);
+    const toolResult = result(fullText, details);
+    const before = structuredClone(toolResult);
+    const view = memoryResultView(toolResult);
+
+    assert.equal(view.status, "success");
+    assert.equal(
+      view.summary,
+      "Saved · target: failure · category: tool-quirk · 16 entries · 92% — 9271/10000 chars",
+    );
+    assert.doesNotMatch(view.summary, /^failure:/);
+    assert.equal(view.expandedText, fullText);
+    assert.deepEqual(toolResult, before);
+
+    const collapsed = renderPlain(
+      createSharedToolResultRenderer(memoryResultView)(
+        toolResult,
+        { expanded: false, isPartial: false },
+        fakeTheme(),
+        { isError: false },
+      ),
+    );
+    assert.match(
+      collapsed,
+      /Saved · target: failure · category: tool-quirk · 16 entries · 92% — 9271\/10000 chars/,
+    );
+    assert.doesNotMatch(collapsed, /^failure:/);
+  });
+});