@agnishc/edb-todo 0.6.1 → 0.8.2

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## [0.8.2] - 2026-05-11
+
+### Added
+- `todo_remove` tool — permanently remove tasks by ID
+- Interactive keyboard navigation in `/todos` viewer (↑↓/jk, g/G, Home/End)
+- Toggle completed task visibility with `c` key in `/todos` viewer
+- Timestamps on tasks: `createdAt`, `startedAt`, `completedAt`
+- Status transition tracking — timestamps update automatically when tasks move between states
+- Percentage display in progress bar
+
+### Changed
+- Replaced module-level mutable globals (`tasks`, `idCounter`) with `TodoStore` class
+- Deduplicated rendering logic — shared `priorityColor()`, `priorityLabel()` helpers used everywhere
+- Priority labels now display as `High`/`Medium`/`Low` instead of `HIG`/`MED`/`LOW`
+- In-progress icon changed from `→` to `●` for visual consistency
+- `/todos` viewer now shows cursor indicator (`❯`) on focused task
+- Section headers show task counts
+- Updated widget status bar to use `●` for active count
+- `todo_write` prompt guidelines now explicitly state completed tasks are never auto-deleted
+
+### Fixed
+- Rendering inconsistency between widget, viewer, and tool results — all now use the same styling
+
+## [0.8.1] - 2026-05-11
+
 ## [0.6.0] - 2026-05-11
 
 ### Changed

package/README.md

@@ -8,6 +8,7 @@ A Pi CLI extension that gives the agent a structured task list to prevent **goal
 2. Before every agent turn, active tasks are injected into the system prompt so the model always knows what remains and what it's currently doing
 3. A live widget above the editor shows the current task list at all times
 4. State is reconstructed from the session branch, so `/tree` navigation and forking work correctly
+5. Completed tasks remain visible in the list — they are never auto-deleted, providing a full audit trail
 
 ## Tools
 
@@ -15,25 +16,45 @@ A Pi CLI extension that gives the agent a structured task list to prevent **goal
 |------|-------------|
 | `todo_write` | Replace the entire task list (atomic update) — always pass all tasks |
 | `todo_read` | Read the current task list and statuses |
+| `todo_remove` | Permanently remove tasks by ID — use for cleanup, not for completed tasks |
 
 ## Task statuses
 
 | Status | Icon | Meaning |
 |--------|------|---------|
 | `pending` | `○` | Not started |
-| `in_progress` | `→` | Actively working — only one at a time |
-| `completed` | `✓` | Done |
+| `in_progress` | `●` | Actively working — only one at a time |
+| `completed` | `✓` | Done — remains in the list |
 
-## Install
+## Task priorities
 
-```bash
-pi install npm:@agnishc/edb-todo
-```
+| Priority | Label | Color |
+|----------|-------|-------|
+| `high` | High | Red |
+| `medium` | Medium | Yellow |
+| `low` | Low | Dim |
 
-## Usage
+## Interactive viewer
 
 ```
-/todos       — open the interactive full-screen task viewer
+/todos       — open the full-screen task viewer
+```
+
+Keyboard controls in the viewer:
+
+| Key | Action |
+|-----|--------|
+| `↑` / `k` | Move cursor up |
+| `↓` / `j` | Move cursor down |
+| `g` / `Home` | Jump to first task |
+| `G` / `End` | Jump to last task |
+| `c` | Toggle completed tasks visibility |
+| `Esc` / `Ctrl+C` | Close viewer |
+
+## Install
+
+```bash
+pi install npm:@agnishc/edb-todo
 ```
 
 ## License

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agnishc/edb-todo",
-	"version": "0.6.1",
+	"version": "0.8.2",
 	"description": "Pi extension: structured task list with live widget and system-prompt injection to prevent goal drift",
 	"keywords": [
 		"pi-package",

package/src/component.ts

@@ -1,22 +1,64 @@
 import { matchesKey, Text, truncateToWidth } from "@earendil-works/pi-tui";
+import { priorityColor, priorityLabel } from "./state";
 import type { Task, TaskDetails } from "./types";
-import { PRIORITY_ORDER, STATUS_ICON } from "./types";
+import { PRIORITY_ORDER } from "./types";
 
 // ── /todos interactive viewer ──────────────────────────────────────────────────
 
 export class TodoViewComponent {
+	private cursorIndex: number = 0;
+	private showCompleted: boolean = true;
 	private cachedWidth?: number;
 	private cachedLines?: string[];
+	private flatTasks: Task[] = [];
 
 	constructor(
 		private readonly tasks: Task[],
 		private readonly theme: any,
 		private readonly onClose: () => void,
-	) {}
+	) {
+		this.rebuildFlatTasks();
+		if (this.flatTasks.length > 0) {
+			this.cursorIndex = Math.min(this.cursorIndex, this.flatTasks.length - 1);
+		}
+	}
 
 	handleInput(data: string): void {
 		if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
 			this.onClose();
+			return;
+		}
+
+		if (matchesKey(data, "up") || data === "k") {
+			if (this.cursorIndex > 0) this.cursorIndex--;
+			this.invalidate();
+			return;
+		}
+
+		if (matchesKey(data, "down") || data === "j") {
+			if (this.cursorIndex < this.flatTasks.length - 1) this.cursorIndex++;
+			this.invalidate();
+			return;
+		}
+
+		if (data === "c") {
+			this.showCompleted = !this.showCompleted;
+			this.rebuildFlatTasks();
+			this.cursorIndex = Math.min(this.cursorIndex, Math.max(0, this.flatTasks.length - 1));
+			this.invalidate();
+			return;
+		}
+
+		if (matchesKey(data, "home") || data === "g") {
+			this.cursorIndex = 0;
+			this.invalidate();
+			return;
+		}
+
+		if (matchesKey(data, "end") || data === "G") {
+			this.cursorIndex = Math.max(0, this.flatTasks.length - 1);
+			this.invalidate();
+			return;
 		}
 	}
 
@@ -31,7 +73,9 @@ export class TodoViewComponent {
 		const titleText = " Tasks ";
 		const sideLen = Math.max(0, width - titleText.length - 3);
 		const headerLine =
-			th.fg("borderMuted", "─".repeat(3)) + th.fg("accent", titleText) + th.fg("borderMuted", "─".repeat(sideLen));
+			th.fg("borderMuted", "─".repeat(3)) +
+			th.fg("accent", th.bold(titleText)) +
+			th.fg("borderMuted", "─".repeat(sideLen));
 		lines.push(truncateToWidth(headerLine, width));
 		lines.push("");
 
@@ -41,43 +85,72 @@ export class TodoViewComponent {
 			// ── Progress bar ──
 			const completedCount = this.tasks.filter((t) => t.status === "completed").length;
 			const total = this.tasks.length;
-			const barWidth = Math.min(24, width - 20);
+			const barWidth = Math.min(20, width - 22);
 			const filled = total > 0 ? Math.round((completedCount / total) * barWidth) : 0;
 			const empty = barWidth - filled;
 			const bar = `[${th.fg("success", "█".repeat(filled))}${th.fg("dim", "░".repeat(empty))}]`;
-			lines.push(truncateToWidth(`  ${bar}  ${th.fg("muted", `${completedCount}/${total} done`)}`, width));
+			const pct = total > 0 ? Math.round((completedCount / total) * 100) : 0;
+			lines.push(
+				truncateToWidth(
+					`  ${bar}  ${th.fg("muted", `${completedCount}/${total}`)} ${th.fg("dim", `(${pct}%)`)}`,
+					width,
+				),
+			);
 			lines.push("");
 
-			// ── In Progress ──
+			// ── Build sections ──
 			const inProgress = this.tasks.filter((t) => t.status === "in_progress");
+			const pending = this.tasks
+				.filter((t) => t.status === "pending")
+				.sort((a, b) => PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority]);
+			const done = this.tasks.filter((t) => t.status === "completed");
+
+			let flatIdx = 0;
+
 			if (inProgress.length > 0) {
-				lines.push(truncateToWidth(`  ${th.fg("accent", "In Progress")}`, width));
-				for (const t of inProgress) lines.push(...this.renderTask(t, width));
+				lines.push(
+					truncateToWidth(
+						`  ${th.fg("accent", th.bold("In Progress"))} ${th.fg("dim", `(${inProgress.length})`)}`,
+						width,
+					),
+				);
+				for (const t of inProgress) {
+					lines.push(...this.renderTask(t, width, flatIdx));
+					flatIdx++;
+				}
 				lines.push("");
 			}
 
-			// ── Pending (sorted by priority) ──
-			const pending = this.tasks
-				.filter((t) => t.status === "pending")
-				.sort((a, b) => PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority]);
 			if (pending.length > 0) {
-				lines.push(truncateToWidth(`  ${th.fg("muted", "Pending")}`, width));
-				for (const t of pending) lines.push(...this.renderTask(t, width));
+				lines.push(
+					truncateToWidth(`  ${th.fg("muted", th.bold("Pending"))} ${th.fg("dim", `(${pending.length})`)}`, width),
+				);
+				for (const t of pending) {
+					lines.push(...this.renderTask(t, width, flatIdx));
+					flatIdx++;
+				}
 				lines.push("");
 			}
 
-			// ── Completed ──
-			const done = this.tasks.filter((t) => t.status === "completed");
-			if (done.length > 0) {
-				lines.push(truncateToWidth(`  ${th.fg("dim", "Completed")}`, width));
-				for (const t of done) lines.push(...this.renderTask(t, width));
+			if (done.length > 0 && this.showCompleted) {
+				lines.push(
+					truncateToWidth(`  ${th.fg("dim", th.bold("Completed"))} ${th.fg("dim", `(${done.length})`)}`, width),
+				);
+				for (const t of done) {
+					lines.push(...this.renderTask(t, width, flatIdx));
+					flatIdx++;
+				}
+				lines.push("");
+			} else if (done.length > 0 && !this.showCompleted) {
+				lines.push(truncateToWidth(`  ${th.fg("dim", `${done.length} completed — press c to show`)}`, width));
 				lines.push("");
 			}
 		}
 
 		// ── Footer ──
 		lines.push(truncateToWidth(th.fg("borderMuted", "─".repeat(width)), width));
-		lines.push(truncateToWidth(`  ${th.fg("dim", "Press Escape to close")}`, width));
+		const keys = ["↑↓ navigate", "c toggle completed", "esc close"];
+		lines.push(truncateToWidth(`  ${th.fg("dim", keys.join("  •  "))}`, width));
 		lines.push("");
 
 		this.cachedWidth = width;
@@ -85,32 +158,59 @@ export class TodoViewComponent {
 		return lines;
 	}
 
-	private renderTask(task: Task, width: number): string[] {
+	private renderTask(task: Task, width: number, flatIdx: number): string[] {
 		const th = this.theme;
+		const isFocused = flatIdx === this.cursorIndex;
 
-		const icon =
-			task.status === "completed"
-				? th.fg("success", STATUS_ICON.completed)
-				: task.status === "in_progress"
-					? th.fg("accent", STATUS_ICON.in_progress)
-					: th.fg("dim", STATUS_ICON.pending);
+		// ── Status icon ──
+		let icon: string;
+		if (task.status === "completed") {
+			icon = th.fg("success", "✓");
+		} else if (task.status === "in_progress") {
+			icon = th.fg("accent", "●");
+		} else {
+			icon = th.fg("dim", "○");
+		}
 
-		const priorityColor = task.priority === "high" ? "error" : task.priority === "medium" ? "warning" : "dim";
-		const pLabel = th.fg(priorityColor, task.priority.toUpperCase().slice(0, 3));
+		// ── Priority badge ──
+		const pColor = priorityColor(task.priority);
+		const pLabel = th.fg(pColor, priorityLabel(task.priority));
 
-		const contentText =
-			task.status === "completed"
-				? th.fg("dim", th.strikethrough(task.content))
-				: task.status === "in_progress"
-					? th.fg("text", th.bold(task.content))
-					: th.fg("muted", task.content);
+		// ── Content ──
+		let contentText: string;
+		if (task.status === "completed") {
+			contentText = th.fg("dim", th.strikethrough(task.content));
+		} else if (task.status === "in_progress") {
+			contentText = th.fg("text", th.bold(task.content));
+		} else {
+			contentText = th.fg("muted", task.content);
+		}
 
+		// ── ID hint ──
 		const idHint = th.fg("dim", ` [${task.id}]`);
 
-		return [truncateToWidth(`    ${icon} ${pLabel}  ${contentText}${idHint}`, width)];
+		// ── Cursor indicator ──
+		const cursor = isFocused ? th.fg("accent", "❯") : " ";
+
+		return [truncateToWidth(`  ${cursor} ${icon} ${pLabel}  ${contentText}${idHint}`, width)];
+	}
+
+	private rebuildFlatTasks(): void {
+		const inProgress = this.tasks.filter((t) => t.status === "in_progress");
+		const pending = this.tasks
+			.filter((t) => t.status === "pending")
+			.sort((a, b) => PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority]);
+		const done = this.showCompleted ? this.tasks.filter((t) => t.status === "completed") : [];
+
+		this.flatTasks = [...inProgress, ...pending, ...done];
 	}
 
-	// ── Tool result rendering ──────────────────────────────────────────────────
+	invalidate(): void {
+		this.cachedWidth = undefined;
+		this.cachedLines = undefined;
+	}
+
+	// ── Tool result rendering (inline, used in both tools) ─────────────────────
 
 	static renderTaskResult(details: TaskDetails | undefined, expanded: boolean, theme: any): any {
 		if (!details?.tasks?.length) {
@@ -119,25 +219,38 @@ export class TodoViewComponent {
 
 		const list = details.tasks;
 		const doneCount = list.filter((t) => t.status === "completed").length;
-		let output = theme.fg("muted", `${doneCount}/${list.length} completed`);
+		const inProgCount = list.filter((t) => t.status === "in_progress").length;
+		const total = list.length;
+
+		// ── Summary line ──
+		const parts: string[] = [];
+		if (inProgCount > 0) parts.push(theme.fg("accent", `● ${inProgCount} active`));
+		parts.push(theme.fg("success", `✓ ${doneCount}/${total} done`));
+		let output = parts.join("  ");
 
+		// ── Task lines ──
 		const display = expanded ? list : list.slice(0, 5);
 		for (const t of display) {
-			const icon =
-				t.status === "completed"
-					? theme.fg("success", STATUS_ICON.completed)
-					: t.status === "in_progress"
-						? theme.fg("accent", STATUS_ICON.in_progress)
-						: theme.fg("dim", STATUS_ICON.pending);
-
-			const pColor = t.priority === "high" ? "error" : t.priority === "medium" ? "warning" : "dim";
-			const pLabel = theme.fg(pColor, t.priority.toUpperCase().slice(0, 3));
-			const content =
-				t.status === "completed"
-					? theme.fg("dim", theme.strikethrough(t.content))
-					: t.status === "in_progress"
-						? theme.fg("text", theme.bold(t.content))
-						: theme.fg("muted", t.content);
+			let icon: string;
+			if (t.status === "completed") {
+				icon = theme.fg("success", "✓");
+			} else if (t.status === "in_progress") {
+				icon = theme.fg("accent", "●");
+			} else {
+				icon = theme.fg("dim", "○");
+			}
+
+			const pColor = priorityColor(t.priority);
+			const pLabel = theme.fg(pColor, priorityLabel(t.priority));
+
+			let content: string;
+			if (t.status === "completed") {
+				content = theme.fg("dim", theme.strikethrough(t.content));
+			} else if (t.status === "in_progress") {
+				content = theme.fg("text", theme.bold(t.content));
+			} else {
+				content = theme.fg("muted", t.content);
+			}
 
 			output += `\n${icon} ${pLabel}  ${content}`;
 		}
@@ -148,9 +261,4 @@ export class TodoViewComponent {
 
 		return new Text(output, 0, 0);
 	}
-
-	invalidate(): void {
-		this.cachedWidth = undefined;
-		this.cachedLines = undefined;
-	}
 }

package/src/index.ts

@@ -1,5 +1,5 @@
 /**
- * pi-todo
+ * edb-todo
  *
  * Task management extension that prevents "goal drift" — the tendency for
  * agents to lose track of the original plan as context grows.
@@ -11,9 +11,10 @@
  *   4. State is stored in tool-result details and reconstructed from the session
  *      branch, so /tree navigation and forking work correctly
  *
- * Tools:   todo_write  — replace the entire task list (atomic update)
- *          todo_read   — read the current task list
- * Command: /todos      — open interactive full-screen task viewer
+ * Tools:   todo_write   — replace the entire task list (atomic update)
+ *          todo_read    — read the current task list
+ *          todo_remove  — remove tasks by ID (permanent deletion)
+ * Command: /todos       — open interactive full-screen task viewer
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
@@ -21,8 +22,8 @@ import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { TodoViewComponent } from "./component";
 import { buildSystemPromptBlock, formatListForLLM } from "./prompt";
-import { TodoWriteParams } from "./schemas";
-import { generateId, reconstructState, setTasks, syncIdCounter, tasks, updateWidget } from "./state";
+import { TodoRemoveParams, TodoWriteParams } from "./schemas";
+import { reconstructState, store, updateWidget } from "./state";
 import type { TaskDetails, TaskPriority, TaskStatus } from "./types";
 
 // ── Extension ──────────────────────────────────────────────────────────────────
@@ -40,8 +41,6 @@ export default function todoExtension(pi: ExtensionAPI): void {
 	});
 
 	// ── System-prompt injection ────────────────────────────────────────────
-	// Active tasks are injected at the start of every agent turn so the model
-	// always knows its current plan — the core mechanism that prevents goal drift.
 	pi.on("before_agent_start", async (event, _ctx) => {
 		const block = buildSystemPromptBlock();
 		if (!block) return;
@@ -68,26 +67,31 @@ export default function todoExtension(pi: ExtensionAPI): void {
 			"Before starting a task, call todo_write to set it to 'in_progress'. " +
 				"Only one task should be 'in_progress' at a time unless tasks are genuinely parallel.",
 			"Immediately after completing a task, call todo_write to mark it 'completed'. " +
-				"Do not batch completions — mark each task done as soon as it is finished.",
+				"Do not batch completions — mark each task done as soon as it is finished. " +
+				"Completed tasks remain visible in the list; they are never automatically deleted.",
 			"todo_write REPLACES the entire list. Always include ALL tasks (both changed and unchanged) in every call.",
+			"To permanently remove tasks, use todo_remove instead of omitting them from todo_write.",
 		],
 		parameters: TodoWriteParams,
 
 		async execute(_id, params, _signal, _onUpdate, ctx) {
-			setTasks(
-				params.tasks.map((t) => ({
-					id: t.id ?? generateId(),
-					content: t.content,
-					status: t.status as TaskStatus,
-					priority: t.priority as TaskPriority,
-				})),
-			);
-			syncIdCounter();
+			const now = Date.now();
+			const updated = params.tasks.map((t) => ({
+				id: t.id ?? store.generateId(),
+				content: t.content,
+				status: t.status as TaskStatus,
+				priority: t.priority as TaskPriority,
+				createdAt: now,
+			}));
+
+			store.applyStatusTransitions(updated);
+			store.setTasks(updated);
+			store.syncIdCounter();
 			updateWidget(ctx);
 
 			return {
 				content: [{ type: "text", text: formatListForLLM() }],
-				details: { tasks: [...tasks] } satisfies TaskDetails,
+				details: { tasks: [...store.tasks] } satisfies TaskDetails,
 			};
 		},
 
@@ -96,9 +100,10 @@ export default function todoExtension(pi: ExtensionAPI): void {
 			const inProg = list.filter((t: any) => t.status === "in_progress").length;
 			const done = list.filter((t: any) => t.status === "completed").length;
 			const total = list.length;
+
 			let text = theme.fg("toolTitle", theme.bold("todo_write "));
 			text += theme.fg("muted", `${total} task${total !== 1 ? "s" : ""}`);
-			if (inProg > 0) text += `  ${theme.fg("accent", `→ ${inProg} active`)}`;
+			if (inProg > 0) text += `  ${theme.fg("accent", `● ${inProg} active`)}`;
 			if (done > 0) text += `  ${theme.fg("success", `✓ ${done} done`)}`;
 			return new Text(text, 0, 0);
 		},
@@ -119,7 +124,7 @@ export default function todoExtension(pi: ExtensionAPI): void {
 		async execute() {
 			return {
 				content: [{ type: "text", text: formatListForLLM() }],
-				details: { tasks: [...tasks] } satisfies TaskDetails,
+				details: { tasks: [...store.tasks] } satisfies TaskDetails,
 			};
 		},
 
@@ -132,16 +137,67 @@ export default function todoExtension(pi: ExtensionAPI): void {
 		},
 	});
 
+	// ── Tool: todo_remove ──────────────────────────────────────────────────
+	pi.registerTool({
+		name: "todo_remove",
+		label: "Tasks",
+		description:
+			"Permanently remove tasks by ID. Use this to clean up tasks that are no longer relevant. " +
+			"Completed tasks normally stay in the list for visibility — only remove if truly unwanted.",
+		promptSnippet: "Remove tasks by ID",
+		promptGuidelines: [
+			"Use todo_remove to permanently delete tasks that are no longer needed. " +
+				"Completed tasks remain visible by default — only remove if they clutter the list.",
+		],
+		parameters: TodoRemoveParams,
+
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			const removed = store.removeByIds(params.ids);
+			updateWidget(ctx);
+
+			if (removed.length === 0) {
+				return {
+					content: [{ type: "text", text: "No matching tasks found." }],
+					details: { tasks: [...store.tasks] } satisfies TaskDetails,
+				};
+			}
+
+			return {
+				content: [
+					{
+						type: "text",
+						text: `Removed ${removed.length} task${removed.length !== 1 ? "s" : ""}: ${removed.join(", ")}\n\n${formatListForLLM()}`,
+					},
+				],
+				details: { tasks: [...store.tasks] } satisfies TaskDetails,
+			};
+		},
+
+		renderCall(args, theme) {
+			const ids = (args.ids as string[]) ?? [];
+			const idStr = ids.map((id: string) => theme.fg("accent", id)).join(", ");
+			return new Text(
+				theme.fg("toolTitle", theme.bold("todo_remove ")) + theme.fg("muted", `remove ${idStr}`),
+				0,
+				0,
+			);
+		},
+
+		renderResult(result, { expanded }, theme) {
+			return TodoViewComponent.renderTaskResult(result.details as TaskDetails | undefined, expanded, theme);
+		},
+	});
+
 	// ── Command: /todos ────────────────────────────────────────────────────
 	pi.registerCommand("todos", {
 		description: "Open the interactive task viewer",
 		handler: async (_args, ctx) => {
 			if (!ctx.hasUI) {
-				ctx.ui.notify(tasks.length === 0 ? "No tasks yet." : formatListForLLM(), "info");
+				ctx.ui.notify(store.tasks.length === 0 ? "No tasks yet." : formatListForLLM(), "info");
 				return;
 			}
 			await ctx.ui.custom<void>((_tui, theme, _kb, done) => {
-				return new TodoViewComponent(tasks, theme, () => done());
+				return new TodoViewComponent(store.tasks, theme, () => done());
 			});
 		},
 	});

package/src/prompt.ts

@@ -1,14 +1,10 @@
-import { activeTasks, tasks } from "./state";
-import { PRIORITY_ORDER, STATUS_ICON } from "./types";
+import { priorityLabel, store } from "./state";
+import { PRIORITY_ORDER } from "./types";
 
 // ── System prompt injection ────────────────────────────────────────────────────
 
-/**
- * Build a plain-text task block for system-prompt injection.
- * Only injected when there are active (non-completed) tasks.
- */
 export function buildSystemPromptBlock(): string {
-	const active = activeTasks();
+	const active = store.activeTasks();
 	if (active.length === 0) return "";
 
 	const lines: string[] = [
@@ -24,15 +20,15 @@ export function buildSystemPromptBlock(): string {
 		.sort((a, b) => PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority]);
 
 	for (const t of [...inProg, ...pending]) {
-		const icon = STATUS_ICON[t.status];
-		const pLabel = `[${t.priority.toUpperCase().slice(0, 3)}]`;
+		const icon = t.status === "in_progress" ? "●" : "○";
+		const pLabel = `[${priorityLabel(t.priority)}]`;
 		const suffix = t.status === "in_progress" ? "  ← in progress" : "";
 		lines.push(`${icon} ${pLabel} ${t.content}${suffix}`);
 	}
 
-	const doneCount = tasks.filter((t) => t.status === "completed").length;
+	const doneCount = store.tasks.filter((t) => t.status === "completed").length;
 	if (doneCount > 0) {
-		lines.push("", `${doneCount}/${tasks.length} tasks completed.`);
+		lines.push("", `${doneCount}/${store.tasks.length} tasks completed.`);
 	}
 
 	return lines.join("\n");
@@ -40,10 +36,12 @@ export function buildSystemPromptBlock(): string {
 
 // ── LLM text formatter ─────────────────────────────────────────────────────────
 
-/** Plain text list returned inside tool results (visible to the LLM). */
 export function formatListForLLM(): string {
-	if (tasks.length === 0) return "Task list is empty.";
-	return tasks
-		.map((t) => `${STATUS_ICON[t.status]} [${t.priority.toUpperCase().slice(0, 3)}] [${t.id}] ${t.content}`)
+	if (store.tasks.length === 0) return "Task list is empty.";
+	return store.tasks
+		.map((t) => {
+			const icon = t.status === "in_progress" ? "●" : t.status === "completed" ? "✓" : "○";
+			return `${icon} [${priorityLabel(t.priority)}] [${t.id}] ${t.content}`;
+		})
 		.join("\n");
 }

package/src/schemas.ts

@@ -33,3 +33,9 @@ export const TodoWriteParams = Type.Object({
 			"both updated ones and unchanged ones.",
 	}),
 });
+
+export const TodoRemoveParams = Type.Object({
+	ids: Type.Array(Type.String(), {
+		description: "Task IDs to remove from the list permanently.",
+	}),
+});

package/src/state.ts

@@ -1,58 +1,106 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { Task, TaskDetails } from "./types";
-import { PRIORITY_ORDER } from "./types";
+import type { Task, TaskDetails, TaskPriority, TaskStatus } from "./types";
 
-// ── Module state ───────────────────────────────────────────────────────────────
+// ── TodoStore ──────────────────────────────────────────────────────────────────
 
-export let tasks: Task[] = [];
-export let idCounter: number = 0;
+export class TodoStore {
+	tasks: Task[] = [];
+	idCounter: number = 0;
 
-// ── State helpers ──────────────────────────────────────────────────────────────
+	generateId(): string {
+		return `t${++this.idCounter}`;
+	}
 
-export function generateId(): string {
-	return `t${++idCounter}`;
-}
+	activeTasks(): Task[] {
+		return this.tasks.filter((t) => t.status !== "completed");
+	}
 
-export function activeTasks(): Task[] {
-	return tasks.filter((t) => t.status !== "completed");
-}
+	setTasks(next: Task[]): void {
+		this.tasks = next;
+	}
 
-export function setTasks(next: Task[]): void {
-	tasks = next;
-}
+	syncIdCounter(): void {
+		for (const t of this.tasks) {
+			const m = t.id.match(/^t(\d+)$/);
+			if (m) this.idCounter = Math.max(this.idCounter, parseInt(m[1]!, 10));
+		}
+	}
+
+	removeByIds(ids: string[]): string[] {
+		const removed: string[] = [];
+		this.tasks = this.tasks.filter((t) => {
+			if (ids.includes(t.id)) {
+				removed.push(t.id);
+				return false;
+			}
+			return true;
+		});
+		return removed;
+	}
 
-export function syncIdCounter(): void {
-	for (const t of tasks) {
-		const m = t.id.match(/^t(\d+)$/);
-		if (m) idCounter = Math.max(idCounter, parseInt(m[1]!, 10));
+	/** Apply status transitions and stamp timestamps accordingly. */
+	applyStatusTransitions(updated: Task[]): void {
+		const now = Date.now();
+		const existing = new Map(this.tasks.map((t) => [t.id, t]));
+
+		for (const task of updated) {
+			const prev = existing.get(task.id);
+			if (!prev) {
+				// New task — set createdAt
+				task.createdAt = task.createdAt ?? now;
+				if (task.status === "in_progress") task.startedAt = now;
+				if (task.status === "completed") {
+					task.startedAt = task.startedAt ?? now;
+					task.completedAt = now;
+				}
+				continue;
+			}
+			// Existing task — carry forward timestamps, apply transitions
+			task.createdAt = prev.createdAt;
+			task.startedAt = prev.startedAt;
+			task.completedAt = prev.completedAt;
+
+			if (prev.status !== "in_progress" && task.status === "in_progress") {
+				task.startedAt = now;
+			}
+			if (prev.status !== "completed" && task.status === "completed") {
+				task.startedAt = task.startedAt ?? now;
+				task.completedAt = now;
+			}
+			// If reverted from completed back to in_progress/pending, clear completedAt
+			if (prev.status === "completed" && task.status !== "completed") {
+				task.completedAt = undefined;
+			}
+		}
 	}
 }
 
+// ── Singleton ──────────────────────────────────────────────────────────────────
+
+export const store = new TodoStore();
+
 // ── Session reconstruction ─────────────────────────────────────────────────────
 
-/**
- * Reconstruct in-memory state by replaying the last todo_write on the branch.
- * Ensures /tree navigation and forking work correctly.
- */
 export function reconstructState(ctx: ExtensionContext): void {
-	tasks = [];
-	idCounter = 0;
+	store.tasks = [];
+	store.idCounter = 0;
+
 	for (const entry of ctx.sessionManager.getBranch()) {
 		if (entry.type !== "message") continue;
 		const msg = entry.message;
 		if (msg.role !== "toolResult" || msg.toolName !== "todo_write") continue;
 		const details = msg.details as TaskDetails | undefined;
 		if (details?.tasks) {
-			tasks = details.tasks;
-			syncIdCounter();
+			store.tasks = details.tasks;
+			store.syncIdCounter();
 		}
 	}
 }
 
-// ── Widget & status bar ────────────────────────────────────────────────────────
+// ── Status bar ─────────────────────────────────────────────────────────────────
 
 export function updateWidget(ctx: ExtensionContext): void {
-	const active = activeTasks();
+	const active = store.activeTasks();
 
 	if (active.length === 0) {
 		ctx.ui.setWidget("pi-todo", undefined);
@@ -63,33 +111,37 @@ export function updateWidget(ctx: ExtensionContext): void {
 	const th = ctx.ui.theme;
 	const inProg = active.filter((t) => t.status === "in_progress");
 	const pending = active.filter((t) => t.status === "pending");
-	const doneCount = tasks.filter((t) => t.status === "completed").length;
+	const doneCount = store.tasks.filter((t) => t.status === "completed").length;
 
-	// ── Footer status ──
 	const parts: string[] = [];
-	if (inProg.length > 0) parts.push(th.fg("accent", `→ ${inProg.length} active`));
+	if (inProg.length > 0) parts.push(th.fg("accent", `● ${inProg.length} active`));
 	if (pending.length > 0) parts.push(th.fg("muted", `○ ${pending.length} pending`));
 	if (doneCount > 0) parts.push(th.fg("success", `✓ ${doneCount} done`));
 	ctx.ui.setStatus("pi-todo", parts.join("  "));
+}
 
-	// ── Widget: show up to 4 active tasks ─────────────────────────────────
-	const displayTasks = [
-		...inProg,
-		...pending.sort((a, b) => PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority]),
-	].slice(0, 4);
-
-	const widgetLines: string[] = [""];
-	for (const t of displayTasks) {
-		const icon = t.status === "in_progress" ? th.fg("accent", "→") : th.fg("dim", "○");
-		const pColor = t.priority === "high" ? "error" : t.priority === "medium" ? "warning" : "dim";
-		const pLabel = th.fg(pColor, t.priority.toUpperCase().slice(0, 3));
-		const content = t.status === "in_progress" ? th.fg("text", th.bold(t.content)) : th.fg("muted", t.content);
-		widgetLines.push(`  ${icon} ${pLabel}  ${content}`);
-	}
-	if (active.length > 4) {
-		widgetLines.push(`  ${th.fg("dim", `... ${active.length - 4} more  (/todos for full list)`)}`);
-	}
-	widgetLines.push("");
+// ── Shared rendering helpers ───────────────────────────────────────────────────
+
+export const PRIORITY_THEME_COLOR: Record<TaskPriority, "error" | "warning" | "dim"> = {
+	high: "error",
+	medium: "warning",
+	low: "dim",
+};
 
-	ctx.ui.setWidget("pi-todo", widgetLines);
+export function priorityColor(p: TaskPriority): "error" | "warning" | "dim" {
+	return PRIORITY_THEME_COLOR[p];
 }
+
+export function priorityLabel(p: TaskPriority): string {
+	return p.toUpperCase().slice(0, 1) + p.slice(1);
+}
+
+export function statusIcon(status: TaskStatus): string {
+	return STATUS_ICON[status];
+}
+
+const STATUS_ICON: Record<TaskStatus, string> = {
+	pending: "○",
+	in_progress: "●",
+	completed: "✓",
+};

package/src/types.ts

@@ -8,6 +8,9 @@ export interface Task {
 	content: string;
 	status: TaskStatus;
 	priority: TaskPriority;
+	createdAt: number;
+	startedAt?: number;
+	completedAt?: number;
 }
 
 export interface TaskDetails {
@@ -18,7 +21,7 @@ export interface TaskDetails {
 
 export const STATUS_ICON: Record<TaskStatus, string> = {
 	pending: "○",
-	in_progress: "→",
+	in_progress: "●",
 	completed: "✓",
 };