@pi-archimedes/todo 2.2.0 → 2.4.0

package/src/tool.test.ts

@@ -0,0 +1,148 @@
+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}`,
+  strikethrough: (text: unknown) => `[s]${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("tool schema", () => {
+  const params = tool.parameters as unknown as {
+    properties: Record<string, { type?: string; enum?: string[]; items?: unknown }>;
+    required?: string[];
+  };
+  const itemSchema = params.properties.todoList?.items as unknown as {
+    properties: Record<string, { type?: string; enum?: string[] }>;
+    required?: string[];
+  };
+
+  it("declares content + canonical status enum, with no id/title and optional description", () => {
+    const props = itemSchema.properties;
+    expect(props.id).toBeUndefined();
+    expect(props.title).toBeUndefined();
+    expect(props.content?.type).toBe("string");
+    expect(props.status?.enum).toEqual(["pending", "in_progress", "completed"]);
+    expect(itemSchema.required).toContain("content");
+    expect(itemSchema.required).toContain("status");
+    expect(itemSchema.required).not.toContain("description");
+  });
+
+  it("keeps the manage_todo_list tool name, op and prepareArguments wiring", () => {
+    expect(tool.name).toBe("manage_todo_list");
+    expect(typeof tool.prepareArguments).toBe("function");
+    expect(params.properties.operation?.enum).toEqual(["write", "read"]);
+  });
+
+  it("model-facing description uses canonical status tokens only", () => {
+    expect(tool.description).not.toMatch(/not-started|in-progress/);
+    expect(tool.description).toContain("in_progress");
+    expect(tool.description).toContain("\"content\": \"Fix the auth middleware\"");
+  });
+});
+
+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: [
+          { content: "a", status: "completed" as const },
+          { content: "b", status: "completed" as const },
+          { content: "c", status: "completed" as const },
+        ],
+      },
+    } as unknown as AgentToolResult<TodoDetails>;
+    const [line] = renderLines(result, false).split("\n");
+    expect(line).toContain("3/3 completed");
+  });
+
+  it("numbers items by array position and renders content", () => {
+    const result = {
+      content: [{ type: "text" as const, text: "1/3 completed." }],
+      details: {
+        operation: "write" as const,
+        todos: [
+          { content: "First", status: "completed" as const },
+          { content: "Second", status: "in_progress" as const },
+          { content: "Third", status: "pending" as const },
+        ],
+      },
+    } as unknown as AgentToolResult<TodoDetails>;
+    const lines = renderLines(result, true);
+    expect(lines).toContain("[accent]1.");
+    expect(lines).toContain("[accent]2.");
+    expect(lines).toContain("[accent]3.");
+    expect(lines).toContain("[s]First");
+    expect(lines).toContain("[warning]Second");
+    expect(lines).toContain("[muted]Third");
+    expect(lines).not.toContain("undefined");
+  });
+});

package/src/tool.ts

@@ -2,19 +2,22 @@ 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";
 
 const TodoItemSchema = Type.Object({
-  id: Type.Number({ description: "Unique identifier for the todo. Use sequential numbers starting from 1." }),
-  title: Type.String({ description: "Concise action-oriented todo label (3-7 words). Displayed in UI." }),
-  description: Type.String({
-    description: "Detailed context, requirements, or implementation notes. Include file paths, specific methods, or acceptance criteria.",
+  content: Type.String({
+    description: "Short imperative label for the task (3-10 words). Displayed in UI. Example: \"Fix the auth middleware\".",
   }),
-  status: StringEnum(["not-started", "in-progress", "completed"] as const, {
-    description: "not-started: Not begun | in-progress: Currently working (multiple allowed for parallel work) | completed: Fully finished with no blockers",
+  status: StringEnum(["pending", "in_progress", "completed"] as const, {
+    description: "pending: Not begun | in_progress: Currently working (multiple allowed for parallel work/subagents) | completed: Fully finished with no blockers",
   }),
+  description: Type.Optional(Type.String({
+    description: "Optional detailed context: file paths, specific methods, or acceptance criteria.",
+  })),
 });
 
 export const ManageTodoListParams = Type.Object({
@@ -36,7 +39,7 @@ When to use this tool:
 - Complex multi-step work requiring planning and tracking
 - When user provides multiple tasks or requests (numbered, comma-separated)
 - After receiving new instructions that require multiple steps
-- BEFORE starting work on any todo (mark as in-progress)
+- BEFORE starting work on any todo (mark as in_progress)
 - IMMEDIATELY after completing each todo (mark completed individually)
 - When breaking down larger tasks into smaller actionable steps
 - To give users visibility into your progress and planning
@@ -48,14 +51,19 @@ When NOT to use:
 
 CRITICAL workflow:
 1. Plan tasks by writing todo list with specific, actionable items
-2. Mark todo(s) as in-progress before starting work
+2. Mark todo(s) as in_progress before starting work
 3. Complete the work for that specific todo
 4. Mark that todo as completed IMMEDIATELY
 5. Move to next todo and repeat
 
+Todo item shape:
+{"content": "Fix the auth middleware", "status": "pending", "description": "optional: file paths, acceptance criteria"}
+- content: the short displayed label — do NOT assign ids (numbering is order)
+- status: exactly one of pending | in_progress | completed
+
 Todo states:
-- not-started: Todo not yet begun
-- in-progress: Currently working (multiple allowed for parallel work/subagents)
+- pending: Todo not yet begun
+- in_progress: Currently working (multiple allowed for parallel work/subagents)
 - completed: Finished successfully
 
 IMPORTANT: Mark todos completed as soon as they are done. Do not batch completions.
@@ -68,6 +76,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,58 +148,68 @@ 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) {
-          const iconChar = STATUS_ICONS[todo.status] ?? "?";
+        for (let i = 0; i < todos.length; i++) {
+          const todo = todos[i]!;
+          const iconChar = (STATUS_ICONS[todo.status] ?? "?").trim();
           const icon =
             todo.status === "completed"
               ? theme.fg("success", iconChar)
-              : todo.status === "in-progress"
+              : todo.status === "in_progress"
                 ? theme.fg("warning", iconChar)
                 : theme.fg("dim", iconChar);
           const title =
             todo.status === "completed"
-              ? theme.fg("dim", theme.strikethrough(todo.title))
-              : todo.status === "in-progress"
-                ? theme.fg("warning", todo.title)
-                : theme.fg("muted", todo.title);
-          text += `\n  ${icon} ${theme.fg("accent", `${todo.id}.`)} ${title}`;
+              ? theme.fg("dim", theme.strikethrough(todo.content ?? ""))
+              : todo.status === "in_progress"
+                ? theme.fg("warning", todo.content ?? "")
+                : theme.fg("muted", todo.content ?? "");
+          text += `\n  ${icon} ${theme.fg("accent", `${i + 1}.`)} ${title}`;
         }
       }
 

package/src/types.ts

@@ -2,17 +2,15 @@
  * Core types for the todo list extension.
  */
 
-/** Status of a single todo item */
-export type TodoStatus = "not-started" | "in-progress" | "completed";
+/** Status of a single todo item (Claude Code aligned). */
+export type TodoStatus = "pending" | "in_progress" | "completed";
 
-/** A single todo item */
+/** A single todo item. No `id` — display numbering is array position. */
 export interface TodoItem {
-  /** Sequential identifier starting from 1 */
-  id: number;
-  /** Concise action-oriented label (3-7 words). Displayed in UI. */
-  title: string;
-  /** Detailed context, requirements, or implementation notes. */
-  description: string;
+  /** Short imperative label of the task (3-10 words). Displayed in UI. */
+  content: string;
+  /** Optional detailed context: file paths, methods, acceptance criteria. */
+  description?: string;
   /** Current status. */
   status: TodoStatus;
 }
@@ -29,7 +27,7 @@ export interface TodoStats {
   total: number;
   completed: number;
   inProgress: number;
-  notStarted: number;
+  pending: number;
 }
 
 /** Validation result */
@@ -40,7 +38,7 @@ export interface ValidationResult {
 
 /** Status icons for each todo state */
 export const STATUS_ICONS: Record<TodoStatus, string> = {
-  "completed": "✓",
-  "in-progress": "◉ ",
-  "not-started": "○",
+  completed: "✓",
+  in_progress: "◉ ",
+  pending: "○",
 };

package/src/ui/todo-widget.ts

@@ -52,7 +52,9 @@ export function updateWidget(
     for (const source of sortedSources) {
       const todos = currentSub.get(source)!;
       if (todos.length > 0) {
-        const agentName = source.replace("subagent:", "");
+        // Per-child sources are subagent:<agent>:<uuid>; render only the agent
+        // name so the header stays `subagent (myagent)` regardless of suffix.
+        const agentName = source.replace("subagent:", "").split(":")[0];
         columns.push({ header: `subagent (${agentName})`, todos });
       }
     }
@@ -103,7 +105,7 @@ export function updateWidget(
                 const todo = column.todos[todoIndex];
                 if (todo) {
                   const icon = getStatusIcon(todo.status, theme);
-                  const idStr = theme.fg("accent", `${todo.id}.`);
+                  const idStr = theme.fg("accent", `${todoIndex + 1}.`);
                   const title = formatTodoTitle(todo, theme);
                   cellText = ` ${icon} ${idStr} ${title}`;
                 } else {
@@ -142,18 +144,18 @@ export function updateWidget(
 function getStatusIcon(status: TodoItem["status"], theme: Theme): string {
   const icon = STATUS_ICONS[status] ?? "?";
   if (status === "completed") return theme.fg("success", icon);
-  if (status === "in-progress") return theme.fg("warning", icon.trim());
+  if (status === "in_progress") return theme.fg("warning", icon.trim());
   return theme.fg("dim", icon);
 }
 
 function formatTodoTitle(todo: TodoItem, theme: Theme): string {
   if (todo.status === "completed") {
-    return theme.fg("dim", theme.strikethrough(todo.title));
+    return theme.fg("dim", theme.strikethrough(todo.content ?? ""));
   }
-  if (todo.status === "in-progress") {
-    return theme.fg("warning", todo.title);
+  if (todo.status === "in_progress") {
+    return theme.fg("warning", todo.content ?? "");
   }
-  return theme.fg("muted", todo.title);
+  return theme.fg("muted", todo.content ?? "");
 }
 
 /** Clear the widget */