@pi-archimedes/todo 2.2.0 → 2.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-archimedes/todo",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "type": "module",
   "keywords": [
     "pi-package"
@@ -11,7 +11,7 @@
   ],
   "main": "./src/index.ts",
   "dependencies": {
-    "@pi-archimedes/core": "2.2.0"
+    "@pi-archimedes/core": "2.3.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": ">=0.1.0",
@@ -19,6 +19,9 @@
     "@earendil-works/pi-tui": ">=0.1.0"
   },
   "devDependencies": {
+    "@earendil-works/pi-ai": "^0.84.2",
+    "@earendil-works/pi-coding-agent": "^0.84.2",
+    "@earendil-works/pi-tui": "^0.84.2",
     "typescript": "^6.0.0"
   },
   "pi": {

package/src/prepare-args.test.ts

@@ -0,0 +1,206 @@
+import { describe, it, expect } from "vitest";
+import {
+  deriveTitleFromDescription,
+  normalizeTodoItem,
+  prepareTodoArguments,
+} from "./prepare-args.js";
+
+// Arguments captured (after JSON decoding) from real failing tool calls in
+// archived sessions — the cases this module exists to repair.
+const REAL_STRINGIFIED_LIST =
+  '[{"id": 1", "title": "Catalog all undocumented env vars", "description": ' +
+  '"Compare env vars from all K8s manifests against what is in AI-SETUP.md", ' +
+  '"status": "completed"}, {"id": 2", "title": "Add K8s env vars section", ' +
+  '"description": "Document all container-level env vars", ' +
+  '"status": "in-progress"}]';
+
+const REAL_MISSING_TITLE = {
+  operation: "write",
+  todoList: [
+    { description: "Understand what c12d4a0 fixed and how the current base interacts with it", id: 1, status: "in-progress" },
+    { description: "Trace user_api_key_auth() catch-all behaviour", id: 2, status: "not-started" },
+  ],
+};
+
+const REAL_MISSING_STATUS = {
+  operation: "write",
+  todoList: [
+    { id: 1, title: "Fix shell command interpolation", description: "fetchNewToken() builds cmd as string" },
+    { id: 2, title: "Update tests", description: "add regression test" },
+  ],
+};
+
+describe("prepareTodoArguments", () => {
+  it("passes through already-valid arguments unchanged", () => {
+    const input = {
+      operation: "write",
+      todoList: [
+        { id: 1, title: "Task", description: "Desc", status: "in-progress" },
+        { id: 2, title: "Other", description: "More", status: "completed" },
+      ],
+    } as const;
+    expect(prepareTodoArguments(input)).toEqual(input);
+  });
+
+  it("passes non-object arguments through untouched", () => {
+    for (const garbage of [null, undefined, 42, "write", [1, 2]]) {
+      expect(prepareTodoArguments(garbage)).toBe(garbage);
+    }
+  });
+
+  it("parses a stringified todoList (real-world case, incl. mangled quotes)", () => {
+    const out = prepareTodoArguments({ operation: "write", todoList: REAL_STRINGIFIED_LIST });
+    expect(out.operation).toBe("write");
+    const list = out.todoList as Array<Record<string, unknown>>;
+    expect(Array.isArray(list)).toBe(true);
+    expect(list).toHaveLength(2);
+    expect(list[0]).toEqual({ id: 1, title: "Catalog all undocumented env vars", description: "Compare env vars from all K8s manifests against what is in AI-SETUP.md", status: "completed" });
+    expect(list[1]).toEqual({ id: 2, title: "Add K8s env vars section", description: "Document all container-level env vars", status: "in-progress" });
+  });
+
+  it("returns a stringified list it cannot parse, so the schema error still fires", () => {
+    const out = prepareTodoArguments({ operation: "write", todoList: "[{ def 《" });
+    expect(out.todoList).toBe("[{ def 《");
+  });
+
+  it("derives a title when the model only sent description", () => {
+    const out = prepareTodoArguments(parseJSON(JSON.stringify(REAL_MISSING_TITLE)));
+    const list = out.todoList as Array<Record<string, unknown>>;
+    expect(list[0]?.title).not.toBe("");
+    expect(list[0]?.description).toBe("Understand what c12d4a0 fixed and how the current base interacts with it");
+    expect(list[1]).toEqual({ id: 2, title: expect.any(String), description: "Trace user_api_key_auth() catch-all behaviour", status: "not-started" });
+  });
+
+  it("defaults missing status to not-started", () => {
+    const out = prepareTodoArguments(parseJSON(JSON.stringify(REAL_MISSING_STATUS)));
+    const list = out.todoList as Array<Record<string, unknown>>;
+    expect(list.every((item) => item?.status === "not-started")).toBe(true);
+  });
+
+  it("normalizes status synonyms and spacing", () => {
+    const out = prepareTodoArguments({
+      operation: "write",
+      todoList: [
+        { id: 1, title: "a", description: "a", status: "In_Progress" },
+        { id: 2, title: "b", description: "b", status: "Done" },
+        { id: 3, title: "c", description: "c", status: "doing" },
+        { id: 4, title: "d", description: "d", status: "Pending" },
+        { id: 5, title: "e", description: "e", status: "CLOSED" },
+        { id: 6, title: "f", description: "f", status: "in-progress" },
+      ],
+    });
+    const list = out.todoList as Array<Record<string, unknown>>;
+    const statuses = list.map((item) => item?.status);
+    expect(statuses).toEqual(["in-progress", "completed", "in-progress", "not-started", "completed", "in-progress"]);
+  });
+
+  it("repairs missing ids (string, null, missing) to sequential numbers", () => {
+    const out = prepareTodoArguments({
+      operation: "write",
+      todoList: [
+        { title: "a", description: "a", status: "not-started" },
+        { id: "4", title: "b", description: "b", status: "not-started" },
+        { id: null, title: "c", description: "c", status: "not-started" },
+      ],
+    });
+    const list = out.todoList as Array<Record<string, unknown>>;
+    expect(list.map((item) => item?.id)).toEqual([1, 4, 3]);
+  });
+
+  it("wraps bare-string items into full items", () => {
+    const out = prepareTodoArguments({ operation: "write", todoList: ["write tests", "deploy it"] });
+    const list = out.todoList as Array<Record<string, unknown>>;
+    expect(list).toEqual([
+      { id: 1, title: "write tests", description: "write tests", status: "not-started" },
+      { id: 2, title: "deploy it", description: "deploy it", status: "not-started" },
+    ]);
+  });
+
+  it("wraps a single bare object in an array and drops extra keys (item + top level)", () => {
+    const out = prepareTodoArguments({
+      operation: "write",
+      extraTop: "drop me",
+      todoList: { id: 1, title: "a", description: "a", status: "completed", fluff: true },
+    });
+    expect(out).toEqual({
+      operation: "write",
+      todoList: [{ id: 1, title: "a", description: "a", status: "completed" }],
+    });
+  });
+
+  it("drops a null todoList and doesn't fabricate one", () => {
+    const out = prepareTodoArguments({ operation: "write", todoList: null });
+    expect(out).toEqual({ operation: "write" });
+    expect(Object.hasOwn(out, "todoList")).toBe(false);
+  });
+
+  it("infers operation from a present list, tolerates casing, and defaults to read", () => {
+    const withList = prepareTodoArguments({ operation: "WRITE-please", todoList: ["x"] });
+    expect(withList.operation).toBe("write");
+    const read = prepareTodoArguments({});
+    expect(read).toEqual({ operation: "read" });
+  });
+
+  it("looks up title/description under the keys models sometimes pick", () => {
+    const out = prepareTodoArguments({
+      operation: "write",
+      todoList: [{ id: 1, content: "Write the thing", details: "Long context here", status: "not-started" }],
+    });
+    const item = (out.todoList as Array<Record<string, unknown>>)[0];
+    expect(item).toEqual({ id: 1, title: "Write the thing", description: "Long context here", status: "not-started" });
+  });
+
+  it("keeps null items null so the schema error stays meaningful", () => {
+    const out = prepareTodoArguments({ operation: "write", todoList: [null, "x"] });
+    expect(out.todoList).toEqual([null, { id: 2, title: "x", description: "x", status: "not-started" }]);
+  });
+
+  it("is idempotent on repaired output", () => {
+    const parsed = parseJSON(
+      JSON.stringify({ ...REAL_MISSING_TITLE, extra: "gap", todoListX: [null] }),
+    ) as Record<string, unknown>;
+    const once = prepareTodoArguments(parsed);
+    const twice = prepareTodoArguments(once);
+    expect(twice).toEqual(once);
+  });
+
+  it("is idempotent on the real-world string + missing-title failures", () => {
+    const once = prepareTodoArguments({ operation: "write", todoList: REAL_STRINGIFIED_LIST });
+    expect(prepareTodoArguments(once)).toEqual(once);
+    expect(prepareTodoArguments(prepareTodoArguments(REAL_MISSING_TITLE))).toEqual(
+      prepareTodoArguments(REAL_MISSING_TITLE),
+    );
+  });
+});
+
+describe("deriveTitleFromDescription", () => {
+  it("returns short descriptions verbatim", () => {
+    expect(deriveTitleFromDescription("  Fix   the  build ")).toBe("Fix the build");
+  });
+
+  it("cuts long descriptions at a word boundary with an ellipsis", () => {
+    const long = "Understand what c12d4a0 fixed and how the current base interacts with it including patch 8";
+    const title = deriveTitleFromDescription(long);
+    expect(title.endsWith("…")).toBe(true);
+    expect(title.length).toBeLessThanOrEqual(61);
+    expect(title.endsWith(" ")).toBe(false);
+  });
+});
+
+describe("normalizeTodoItem", () => {
+  it("keeps a textless item as an empty item", () => {
+    expect(normalizeTodoItem({}, 0)).toEqual({ id: 1, title: "", description: "", status: "not-started" });
+  });
+
+  it("returns non-object items unchanged", () => {
+    expect(normalizeTodoItem(3, 0)).toBe(3);
+    expect(normalizeTodoItem("", 0)).toBe("");
+  });
+});
+
+// ── helpers ─────────────────────────────────────────────────────────────────
+
+// Deep-clone fixture objects, mirroring how arguments arrive (post-JSON).
+function parseJSON(s: string): unknown {
+  return JSON.parse(s) as unknown;
+}

package/src/prepare-args.ts

@@ -0,0 +1,236 @@
+/**
+ * Compatibility shim for LLM tool-call arguments.
+ *
+ * Wires into the tool via `prepareArguments`, which pi runs BEFORE schema
+ * validation (and before `execute`). The model occasionally sends
+ * malformed-but-recoverable `manage_todo_list` arguments; observed in practice:
+ *
+ *   - `todoList` is a stringified JSON array instead of an array (sometimes
+ *     with mangled escaping, e.g. `"id": 1"` — an extra quote after the number)
+ *   - items are missing `title` because the model considers it redundant
+ *     with `description`
+ *   - items are missing `status` (or it is a non-enum phrase like "doing")
+ *   - items are plain strings
+ *   - `id` missing or a numeric string
+ *   - stray top-level / per-item keys outside the schema
+ *
+ * Only *recoverable* deviations are repaired. Anything unrecoverable is passed
+ * through untouched so the standard validation error still surfaces with the
+ * real complaint. The public schema stays strict; this module is purely a
+ * repair layer.
+ */
+
+import type { ManageTodoListInput } from "./tool.js";
+import type { TodoStatus } from "./types.js";
+
+type Record_ = Record<string, unknown>;
+
+const VALID_STATUSES: ReadonlySet<string> = new Set<string>([
+  "not-started",
+  "in-progress",
+  "completed",
+]);
+
+/** LLM synonyms for the three enum values (after case/spacing normalization). */
+const STATUS_ALIASES: ReadonlyMap<string, TodoStatus> = new Map<string, TodoStatus>([
+  ["done", "completed"],
+  ["complete", "completed"],
+  ["finished", "completed"],
+  ["closed", "completed"],
+  ["success", "completed"],
+  ["passed", "completed"],
+  ["doing", "in-progress"],
+  ["started", "in-progress"],
+  ["working", "in-progress"],
+  ["active", "in-progress"],
+  ["wip", "in-progress"],
+  ["ongoing", "in-progress"],
+  ["pending", "not-started"],
+  ["todo", "not-started"],
+  ["planned", "not-started"],
+  ["untouched", "not-started"],
+]);
+
+/**
+ * Keys the model sometimes uses instead of `title`/`description`. Checked
+ * only when the canonical field is itself missing, so a model that DID send
+ * `title`/`description` is never overwritten.
+ */
+const TITLE_FALLBACK_KEYS = ["content", "task", "text", "name", "label"] as const;
+const DESCRIPTION_FALLBACK_KEYS = ["details", "notes", "summary", "context"] as const;
+
+/** Upper bound for a `title` derived from `description`. */
+const DERIVED_TITLE_MAX = 60;
+
+function isRecord(value: unknown): value is Record_ {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function firstStringOf(record: Record_, keys: readonly string[]): string {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim() !== "") return value;
+  }
+  return "";
+}
+
+/**
+ * Collapse whitespace and cut at a word boundary so a derived title stays a
+ * short, human-readable label in the widget.
+ */
+export function deriveTitleFromDescription(description: string): string {
+  const flat = description.replace(/\s+/g, " ").trim();
+  if (flat.length <= DERIVED_TITLE_MAX) return flat;
+  const cut = flat.slice(0, DERIVED_TITLE_MAX);
+  const lastSpace = cut.lastIndexOf(" ");
+  const head = lastSpace > 0 ? cut.slice(0, lastSpace) : cut;
+  return `${head.trimEnd()}…`;
+}
+
+function normalizeId(raw: unknown, index: number): number {
+  let n: number;
+  if (typeof raw === "number") {
+    n = raw;
+  } else if (typeof raw === "string" && raw.trim() !== "") {
+    n = Number(raw);
+  } else {
+    n = Number.NaN;
+  }
+  return Number.isFinite(n) ? Math.trunc(n) : index + 1;
+}
+
+function normalizeStatus(raw: unknown): TodoStatus {
+  if (typeof raw !== "string") {
+    // Missing, null, number, … — no signal about intent.
+    return "not-started";
+  }
+  // "in progress" / "In_Progress" / "IN-PROGRESS" → "in-progress"
+  const normalized = raw.trim().toLowerCase().replace(/[_\s]+/g, "-");
+  if (VALID_STATUSES.has(normalized)) return normalized as TodoStatus;
+  return STATUS_ALIASES.get(normalized) ?? "not-started";
+}
+
+/**
+ * Normalize one todo item. Returns a fresh object containing ONLY the four
+ * schema keys (extra keys are dropped — the schema rejects them with "must
+ * not have additional properties"). Unrecoverable items are returned as-is so
+ * the schema error keeps its meaning.
+ */
+export function normalizeTodoItem(raw: unknown, index: number): unknown {
+  // Laziest form: ["write tests", "deploy"]
+  if (typeof raw === "string") {
+    const text = raw.trim();
+    if (text === "") return raw;
+    return {
+      id: index + 1,
+      title: deriveTitleFromDescription(text),
+      description: text,
+      status: "not-started" as TodoStatus,
+    };
+  }
+
+  if (!isRecord(raw)) return raw; // null / number / nested array → schema error
+
+  const description =
+    (typeof raw.description === "string" ? raw.description.trim() : "") ||
+    firstStringOf(raw, DESCRIPTION_FALLBACK_KEYS);
+  let title = typeof raw.title === "string" ? raw.title.trim() : "";
+  if (title === "") title = firstStringOf(raw, TITLE_FALLBACK_KEYS);
+  if (title === "" && description !== "") title = deriveTitleFromDescription(description);
+
+  // No text at all: keep the (empty) fields so the schema error lists the
+  // missing `title`/`description` instead of masking it with a derivation.
+  return {
+    id: normalizeId(raw.id, index),
+    title,
+    description: description || title,
+    status: normalizeStatus(raw.status),
+  };
+}
+
+/**
+ * Repair the occasional mangled JSON: `"id": 1"` (an extra quote after the
+ * number). The replacement is safe to apply blindly — that shape is invalid
+ * JSON to begin with.
+ */
+// The long backslash sequence is spelled out as char codes for robustness.
+const ID_FIX_PATTERN = String.fromCharCode(40, 34, 105, 100, 34, 92, 115, 42, 58, 92, 115, 42, 92, 100, 43, 41, 92, 34);
+const ID_QUOTE_FIX = new RegExp(ID_FIX_PATTERN, "g");
+function repairStringifiedJson(s: string): string {
+  return s.replace(ID_QUOTE_FIX, "$1");
+}
+
+function parseStringifiedList(raw: string): unknown {
+  try {
+    return JSON.parse(repairStringifiedJson(raw));
+  } catch {
+    return raw; // Unparseable — keep the string; schema error says "must be array"
+  }
+}
+
+function looksLikeTodoItem(value: unknown): boolean {
+  return (
+    isRecord(value) &&
+    ("id" in value || "title" in value || "description" in value || "status" in value)
+  );
+}
+
+/**
+ * Normalize the `todoList` argument. `kept` is false only when the field was
+ * absent and must not appear in the output object at all.
+ */
+function normalizeTodoList(raw: unknown): { value: unknown; kept: boolean } {
+  let value: unknown = raw;
+  if (typeof raw === "string") value = parseStringifiedList(raw);
+
+  if (value === null) {
+    // Required-schema fields reject null; dropping the key yields the clearer
+    // "todoList is required for write operation" from execute().
+    return { value: undefined, kept: true };
+  }
+
+  if (value === undefined) return { value, kept: false };
+
+  if (Array.isArray(value)) {
+    return { value: value.map((item, i) => normalizeTodoItem(item, i)), kept: true };
+  }
+
+  // A single bare item instead of an array.
+  if (looksLikeTodoItem(value)) {
+    return { value: [normalizeTodoItem(value, 0)], kept: true };
+  }
+
+  return { value, kept: true }; // Unmendable — original validation error stands
+}
+
+function normalizeOperation(raw: unknown, listPresent: boolean): "write" | "read" {
+  if (raw === "write" || raw === "read") return raw;
+  if (typeof raw === "string") {
+    const lowered = raw.trim().toLowerCase();
+    if (lowered === "write" || lowered === "read") return lowered;
+  }
+  // Model omitted/garbled the operation: a list implies a write.
+  return listPresent ? "write" : "read";
+}
+
+/**
+ * Repair raw `manage_todo_list` call arguments before schema validation.
+ * Never throws, never mutates its input, and passes through anything it
+ * cannot recover.
+ */
+export function prepareTodoArguments(args: unknown): ManageTodoListInput {
+  if (!isRecord(args)) return args as ManageTodoListInput;
+
+  const normalized =
+    args.todoList === undefined ? undefined : normalizeTodoList(args.todoList);
+  const present =
+    normalized !== undefined && normalized.kept && normalized.value !== undefined;
+
+  const out: Record_ = {
+    operation: normalizeOperation(args.operation, present),
+  };
+  if (present) {
+    out.todoList = (normalized as { value: unknown }).value;
+  }
+  return out as ManageTodoListInput;
+}

package/src/tool.test.ts

@@ -0,0 +1,91 @@
+import { describe, it, expect } from "vitest";
+import type { AgentToolResult, Theme } from "@earendil-works/pi-coding-agent";
+import { createManageTodoListTool } from "./tool.js";
+import { TodoStateManager } from "./state-manager.js";
+import type { TodoDetails } from "./types.js";
+
+const VALIDATION_ERROR_TEXT = [
+  'Validation failed for tool "manage_todo_list":',
+  '  - todoList.0: must be object',
+  "",
+  "Received arguments:",
+  '{',
+  '  "operation": "write",',
+  '  "todoList": "this is definitely not a list, ascii only"',
+  "}",
+].join("\n");
+
+// Theme stub: render (token, text) as [token]text so assertions can
+// tell apart the status colour, the glyph, and the label.
+const theme = {
+  fg: (token: unknown, text: unknown) => `[${token}]${text}`,
+} as unknown as Theme;
+
+const tool = createManageTodoListTool(new TodoStateManager(), () => {});
+
+function renderLines(result: AgentToolResult<TodoDetails | undefined>, expanded: boolean): string {
+  const view = tool.renderResult(result, { expanded, isPartial: false }, theme) as {
+    render(width: number): string[];
+  };
+  expect(view).toBeDefined();
+  return view.render(200).map((line) => line.trimEnd()).join("\n");
+}
+
+const harnessErrorResult = (text: string) =>
+  ({
+    content: [{ type: "text" as const, text }],
+    // Exactly what the harness attaches to rejected calls (createErrorToolResult):
+    // a truthy empty details object.
+    details: {},
+  }) as unknown as AgentToolResult<TodoDetails | undefined>;
+
+describe("renderResult — harness error shapes", () => {
+  it("collapsed validation failure → single red ✗ line, no raw argument dump", () => {
+    const lines = renderLines(harnessErrorResult(VALIDATION_ERROR_TEXT), false).split("\n");
+      expect(lines.length).toBe(1);
+      const [line] = lines;
+      expect(line).toContain("✗");
+      expect(line).toContain("invalid arguments");
+      expect(line).not.toContain("Validation failed");
+      expect(line).not.toContain("Received arguments");
+      expect(line).not.toContain("definitely not a list");
+  });
+
+  it("expanded validation failure → the full harness message", () => {
+    const lines = renderLines(harnessErrorResult(VALIDATION_ERROR_TEXT), true);
+    expect(lines).toBe(VALIDATION_ERROR_TEXT);
+  });
+
+  it("results without any details at all → same compact treatment", () => {
+    const noDetails = {
+      content: [{ type: "text" as const, text: "Tool execution was blocked" }],
+    } as unknown as AgentToolResult<TodoDetails | undefined>;
+    const [line] = renderLines(noDetails, false).split("\n");
+    expect(line).toContain("✗");
+    expect(line).toContain("blocked");
+  });
+
+  it("non-validation errors stay short and line-less-newline", () => {
+    const [line] = renderLines(harnessErrorResult("Some multi-line\nharness message here"), false).split("\n");
+    expect(line).toContain("✗");
+    expect(line).not.toContain("\n");
+  });
+});
+
+describe("renderResult — successful results unchanged", () => {
+  it("renders the completed counter from details.todos", () => {
+    const result = {
+      content: [{ type: "text" as const, text: "3/3 completed." }],
+      details: {
+        operation: "write" as const,
+        todos: [
+          { id: 1, title: "a", description: "a", status: "completed" as const },
+          { id: 2, title: "b", description: "b", status: "completed" as const },
+          { id: 3, title: "c", description: "c", status: "completed" as const },
+        ],
+      },
+    } as unknown as AgentToolResult<TodoDetails>;
+    const [line] = renderLines(result, false).split("\n");
+    expect(line).toContain("3/3 completed");
+  });
+});

package/src/tool.ts

@@ -2,6 +2,8 @@ import { type Static, StringEnum, Type } from "@earendil-works/pi-ai";
 import type { AgentToolResult, ExtensionContext, Theme, ToolRenderResultOptions } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { getBus, Events } from "@pi-archimedes/core/bus";
+import { renderToolHeader, renderStatusLabel } from "@pi-archimedes/core/tool-render";
+import { prepareTodoArguments } from "./prepare-args.js";
 import type { TodoStateManager } from "./state-manager.js";
 import { STATUS_ICONS } from "./types.js";
 import type { TodoDetails } from "./types.js";
@@ -68,6 +70,11 @@ export function createManageTodoListTool(state: TodoStateManager, onUpdate: () =
     description: TOOL_DESCRIPTION,
     parameters: ManageTodoListParams,
 
+    // Repair common model mistakes (stringified arrays, missing
+    // title/status, bare-string items) BEFORE schema validation. See
+    // prepare-args.ts.
+    prepareArguments: prepareTodoArguments,
+
     async execute(
       _toolCallId: string,
       params: ManageTodoListInput,
@@ -135,41 +142,50 @@ export function createManageTodoListTool(state: TodoStateManager, onUpdate: () =
     },
 
     renderCall(args: ManageTodoListInput, theme: Theme) {
-      let text = theme.fg("toolTitle", theme.bold("manage_todo_list "));
-      text += theme.fg("muted", args.operation);
-
-      if (args.operation === "write" && args.todoList) {
-        const count = args.todoList.length;
-        text += theme.fg("dim", ` (${count} item${count !== 1 ? "s" : ""})`);
-      }
-
-      return new Text(text, 0, 0);
+      return new Text(renderToolHeader("todo", args.operation, theme), 0, 0);
     },
 
     renderResult(
       result: AgentToolResult<TodoDetails | undefined>,
-      { expanded }: ToolRenderResultOptions,
+      { expanded, isPartial }: ToolRenderResultOptions,
       theme: Theme
     ) {
       const details = result.details;
-      if (!details) {
+
+      // execute() always carries details.todos. Anything else — including
+      // the harness' rejection results, which attach details: {} — means
+      // execute() never ran (validation failure, blocked call, abort).
+      // Collapsed, show a single red ✗ line; the full message on expand.
+      if (!details || !Array.isArray(details.todos)) {
         const first = result.content[0];
-        return new Text(first && "text" in first ? first.text : "", 0, 0);
+        const text = first && "text" in first && typeof first.text === "string" ? first.text : "";
+        if (!expanded) {
+          const label = /validation failed for tool/i.test(text)
+            ? "invalid arguments"
+            : text.replace(/\s+/g, " ").trim().slice(0, 100);
+          return new Text(label ? renderStatusLabel("error", label, theme) : "", 0, 0);
+        }
+        return new Text(text, 0, 0);
       }
 
       if (details.error) {
-        return new Text(theme.fg("error", `✗ ${details.error}`), 0, 0);
+        return new Text(renderStatusLabel("error", details.error, theme), 0, 0);
       }
 
       const todos = details.todos;
       const completed = todos.filter((t) => t.status === "completed").length;
       const total = todos.length;
+      const label = `${completed}/${total} completed`;
+
+      if (isPartial) {
+        return new Text(renderStatusLabel("running", label, theme), 0, 0);
+      }
 
       if (total === 0) {
         return new Text(theme.fg("dim", "No todos"), 0, 0);
       }
 
-      let text = theme.fg("success", "✓ ") + theme.fg("muted", `${completed}/${total} completed`);
+      let text = renderStatusLabel("success", label, theme);
 
       if (expanded) {
         for (const todo of todos) {