@xynogen/pix-todo 0.3.2 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-todo",
-	"version": "0.3.2",
+	"version": "0.4.0",
 	"description": "Pi tool — durable execution checklist (todo)",
 	"type": "module",
 	"main": "src/index.ts",
@@ -9,6 +9,7 @@
 	},
 	"files": [
 		"src",
+		"!src/**/*.test.*",
 		"README.md",
 		"LICENSE"
 	],

package/src/todo.ts

@@ -172,6 +172,35 @@ const parseItems = (raw: string): string[] =>
 		.map((l) => l.replace(/^\s*(?:\d+[.)]|[-*•])\s*/, "").trim())
 		.filter(Boolean);
 
+const STATUSES: readonly TodoStatus[] = ["pending", "in_progress", "done", "blocked"];
+
+export interface TodoUpdateOp {
+	id: number;
+	status: TodoStatus;
+}
+
+/**
+ * Parse the batch `updates` string: comma/newline separated `id:status` pairs
+ * (e.g. "3:done, 4:blocked"). Returns an error string on the first bad token so
+ * the model gets one precise correction instead of a silent partial apply.
+ */
+export function parseUpdates(raw: string): { ops: TodoUpdateOp[] } | { error: string } {
+	const ops: TodoUpdateOp[] = [];
+	for (const token of raw.split(/[,\n]/)) {
+		const tok = token.trim();
+		if (!tok) continue;
+		const m = /^#?(\d+)\s*[:=]\s*(\w+)$/.exec(tok);
+		if (!m) return { error: `Bad update token "${tok}" — expected "id:status".` };
+		const status = m[2] as TodoStatus;
+		if (!STATUSES.includes(status))
+			return { error: `Bad status "${m[2]}" — expected one of ${STATUSES.join(", ")}.` };
+		ops.push({ id: Number(m[1]), status });
+	}
+	return ops.length
+		? { ops }
+		: { error: 'update requires `updates` ("id:status") or `id`+`status`.' };
+}
+
 export default function registerTodo(pi: ExtensionAPI): void {
 	once(pi, "pix-todo", () => {
 		let todos: TodoItem[] = [];
@@ -212,6 +241,16 @@ export default function registerTodo(pi: ExtensionAPI): void {
 			return `Todos ${done}/${todos.length} done:\n${lines.join("\n")}`;
 		}
 
+		/** Compact next-step hint for the delta echo — the full list is already in
+		 *  the transcript and the tool card, so re-sending it is token waste. */
+		function todoHint(): string {
+			const done = todos.filter((t) => t.status === "done").length;
+			const next =
+				todos.find((t) => t.status === "in_progress") ?? todos.find((t) => t.status === "pending");
+			if (!next) return `${done}/${todos.length} done — all items closed.`;
+			return `${done}/${todos.length} done — next #${next.id} ${next.text}`;
+		}
+
 		// Durable execution checklist for BUILD mode. Survives context compaction
 		// and session restore. Workflows like plan instruct the model to seed it
 		// from a plan's "Implementation Phases" so it stays anchored to plan.md.
@@ -222,12 +261,12 @@ export default function registerTodo(pi: ExtensionAPI): void {
 			// result row and should align its status glyph with other compact tools.
 			renderShell: "self",
 			description:
-				"Track BUILD-phase execution progress. Durable across context compaction. Actions: list, set (replace all items from newline/numbered text), add, update (change one item's status), clear.",
+				"Track BUILD-phase execution progress. Durable across context compaction. Actions: list, set (replace all items from newline/numbered text), add, update (change one or more items' status — batch via `updates`), clear.",
 			promptSnippet:
-				"todo(action, items?, id?, status?, text?) — action: list|set|add|update|clear. Use to track implementation progress, especially when executing a plan.",
+				"todo(action, items?, updates?, id?, status?, text?) — action: list|set|add|update|clear. Use to track implementation progress, especially when executing a plan.",
 			promptGuidelines: [
 				"When you start executing a multi-step plan in BUILD mode, seed the todo list with `todo(action:'set', items: <plan Implementation Phases>)`.",
-				"Mark each item in_progress before working it via `todo(action:'update', id, status)`; opening one auto-closes every earlier item, so just open the next and skipped steps mark done themselves.",
+				"Batch status changes in ONE call: `todo(action:'update', updates:'3:done,4:in_progress')`. Opening an item auto-closes earlier ones (ordered lists), so do not send per-item update calls.",
 				"When marking an item done, the tool checks for earlier incomplete items and warns you — resolve each skipped item (mark done or blocked) before moving on.",
 				"If the list is NOT a sequential run (items independent, done in any order), pass `ordered:false` on `set` — that disables the cascade-close and skip warning.",
 				"Call `todo(action:'list')` to recover your place after long runs or context compaction.",
@@ -236,14 +275,20 @@ export default function registerTodo(pi: ExtensionAPI): void {
 				action: Type.Enum(["list", "set", "add", "update", "clear"] as const, {
 					type: "string",
 					description:
-						'Required operation: "list" shows items; "set" replaces all from items; "add" appends items; "update" changes one item by id; "clear" removes all.',
+						'Required operation: "list" shows items; "set" replaces all from items; "add" appends items; "update" changes one or more items by id; "clear" removes all.',
 				}),
 				items: Type.Optional(
 					Type.String({
 						description: "For set/add: newline-separated or numbered list of todo texts.",
 					}),
 				),
-				id: Type.Optional(Type.Number({ description: "For update: target todo id." })),
+				updates: Type.Optional(
+					Type.String({
+						description:
+							'For update (preferred for status changes): comma-separated "id:status" pairs, e.g. "3:done,4:in_progress". Applied in order.',
+					}),
+				),
+				id: Type.Optional(Type.Number({ description: "For update: single target todo id." })),
 				status: Type.Optional(
 					Type.Enum(["pending", "in_progress", "done", "blocked"] as const, {
 						type: "string",
@@ -342,30 +387,73 @@ export default function registerTodo(pi: ExtensionAPI): void {
 					}
 
 					case "update": {
-						const t = todos.find((x) => x.id === params.id);
-						if (!t) return fail(`No todo with id ${params.id}.`);
+						// Batch form (`updates`) is preferred — one call closes many items.
+						// Single form (`id`+`status`/`text`) stays supported for renames.
+						let ops: TodoUpdateOp[];
+						if (params.updates) {
+							const parsed = parseUpdates(params.updates as string);
+							if ("error" in parsed) return fail(parsed.error);
+							ops = parsed.ops;
+						} else if (params.id !== undefined && params.status) {
+							ops = [{ id: params.id as number, status: params.status as TodoStatus }];
+						} else {
+							ops = [];
+						}
+
+						const missing = ops.filter((o) => !todos.some((t) => t.id === o.id)).map((o) => o.id);
+						if (missing.length) return fail(`No todo with id ${missing.join(", ")}.`);
+
+						// Text-only / no-op single update: keep the legacy tolerant path.
+						if (!ops.length) {
+							const t = todos.find((x) => x.id === params.id);
+							if (!t) return fail(`No todo with id ${params.id}.`);
+							if (params.text) {
+								t.text = params.text;
+								persistTodos();
+							}
+							return ok(`#${t.id} ${t.status} · ${todoHint()}`);
+						}
+
+						const autoClosed = new Set<number>();
 						let skipWarning = "";
-						if (params.status) {
+						for (const op of ops) {
+							const t = todos.find((x) => x.id === op.id) as TodoItem;
 							// Sequential-progress invariant (ordered lists only): opening a task
 							// means everything before it is finished. Cascade-close every earlier
 							// pending or in_progress item so the model never has to mark skipped
 							// steps done by hand. `blocked` is left untouched. Unordered lists
 							// treat each item independently — no cascade, no skip warning.
-							if (ordered && params.status === "in_progress")
+							if (ordered && op.status === "in_progress")
 								for (const other of todos)
 									if (
 										other.id < t.id &&
 										(other.status === "pending" || other.status === "in_progress")
-									)
+									) {
 										other.status = "done";
+										autoClosed.add(other.id);
+									}
 
-							if (ordered && params.status === "done") skipWarning = buildSkipWarning(todos, t.id);
-
-							t.status = params.status;
+							// Only the last op's skip state matters — earlier ops in the same
+							// batch may legitimately still be settling.
+							skipWarning = ordered && op.status === "done" ? buildSkipWarning(todos, t.id) : "";
+							t.status = op.status;
+						}
+						// Text rename only applies to a single-target update.
+						const only = ops.length === 1 ? ops[0] : undefined;
+						if (params.text && only) {
+							const t = todos.find((x) => x.id === only.id) as TodoItem;
+							t.text = params.text;
 						}
-						if (params.text) t.text = params.text;
 						persistTodos();
-						return ok(todoSummary() + skipWarning);
+
+						// Delta-only echo: the model already holds the list; re-sending it on
+						// every update is pure token waste. The TUI card still renders the
+						// full checklist from `details.snapshot`.
+						const applied = ops.map((o) => `#${o.id} ${o.status}`).join(", ");
+						const auto = autoClosed.size
+							? ` (auto-done ${[...autoClosed].map((i) => `#${i}`).join(",")})`
+							: "";
+						return ok(`${applied}${auto} · ${todoHint()}${skipWarning}`);
 					}
 
 					case "clear":

package/src/todo.test.ts

@@ -1,1012 +0,0 @@
-import { beforeEach, describe, expect, test } from "bun:test";
-import registerTodo, { renderTodoLines, renderTodoSummaryLine, type TodoItem } from "./todo.ts";
-
-// registerTodo wraps its body in once(pi, "pix-todo") — a per-instance
-// WeakMap guard that dedupes activation across pix-core + a standalone install.
-// Tests re-register a fresh host per case. Clear the registry between tests so
-// that the same pi object can be re-used without cross-test interference.
-beforeEach(() => {
-	delete (globalThis as { __pixOnce?: WeakMap<object, Set<string>> }).__pixOnce;
-});
-
-// Stub theme tags each fragment with its color/bold so assertions can verify
-// which status got which tint, without depending on real ANSI codes.
-const tagTheme = {
-	fg: (color: string, text: string) => `[${color}]${text}[/]`,
-	bold: (text: string) => `<b>${text}</b>`,
-};
-
-// ─── Helpers ────────────────────────────────────────────────────────────────
-
-/** Create a mock ExtensionAPI that captures the registered tool's execute fn. */
-function makeHost(
-	initialEntries: Array<{
-		type: string;
-		customType?: string;
-		data?: unknown;
-	}> = [],
-) {
-	let capturedParameters: unknown;
-	let capturedRenderShell: unknown;
-	let capturedExecute:
-		| ((
-				id: string,
-				params: Record<string, unknown>,
-		  ) => Promise<{
-				content: Array<{ type: string; text: string }>;
-				details?: unknown;
-				isError?: boolean;
-		  }>)
-		| null = null;
-	const appendCalls: Array<{ type: string; data: unknown }> = [];
-	const handlers: Record<string, Array<(event: unknown, ctx?: unknown) => unknown>> = {};
-
-	let capturedRender:
-		| ((
-				result: unknown,
-				options: unknown,
-				theme: unknown,
-				context: unknown,
-		  ) => { render(width: number): string[] })
-		| null = null;
-	let capturedRenderCall:
-		| ((args: unknown, theme: unknown, context: unknown) => { render(width: number): string[] })
-		| null = null;
-
-	const pi = {
-		registerTool(def: {
-			name: string;
-			parameters: unknown;
-			execute: typeof capturedExecute;
-			renderShell?: unknown;
-			renderCall?: typeof capturedRenderCall;
-			renderResult?: typeof capturedRender;
-		}) {
-			capturedParameters = def.parameters;
-			capturedRenderShell = def.renderShell;
-			capturedExecute = def.execute;
-			if (def.renderCall) capturedRenderCall = def.renderCall;
-			if (def.renderResult) capturedRender = def.renderResult;
-		},
-		appendEntry(type: string, data: unknown) {
-			appendCalls.push({ type, data });
-		},
-		on(ev: string, fn: (event: unknown, ctx?: unknown) => unknown) {
-			if (!handlers[ev]) handlers[ev] = [];
-			handlers[ev].push(fn);
-		},
-		async emit(ev: string, event?: unknown, ctx?: unknown): Promise<unknown> {
-			let last: unknown;
-			for (const fn of handlers[ev] ?? []) {
-				const result = await fn(event, ctx);
-				if (result !== undefined) last = result;
-			}
-			return last;
-		},
-	} as never;
-
-	const sessionManager = {
-		getEntries() {
-			return initialEntries;
-		},
-	};
-
-	return {
-		pi,
-		sessionManager,
-		get parameters() {
-			if (!capturedParameters) throw new Error("parameters not captured");
-			return capturedParameters;
-		},
-		get execute() {
-			if (!capturedExecute) throw new Error("execute not captured");
-			return capturedExecute;
-		},
-		get renderShell() {
-			return capturedRenderShell;
-		},
-		get renderCall() {
-			if (!capturedRenderCall) throw new Error("renderCall not captured");
-			return capturedRenderCall;
-		},
-		get render() {
-			if (!capturedRender) throw new Error("render not captured");
-			return capturedRender;
-		},
-		appendCalls,
-		async emit(ev: string, event?: unknown, ctx?: unknown): Promise<unknown> {
-			let last: unknown;
-			for (const fn of handlers[ev] ?? []) {
-				const result = await fn(event, ctx);
-				if (result !== undefined) last = result;
-			}
-			return last;
-		},
-	};
-}
-
-async function run(
-	execute: (
-		id: string,
-		params: Record<string, unknown>,
-	) => Promise<{
-		content: Array<{ type: string; text: string }>;
-		details?: unknown;
-		isError?: boolean;
-	}>,
-	params: Record<string, unknown>,
-) {
-	return execute("call-1", params);
-}
-
-function text(result: { content: Array<{ type: string; text: string }> }) {
-	return result.content.map((c) => c.text).join("\n");
-}
-
-// ─── Tool schema ────────────────────────────────────────────────────────────
-
-test("todo exposes action and status as guided string enums", () => {
-	const host = makeHost();
-	registerTodo(host.pi);
-	const schema = host.parameters as {
-		properties: {
-			action: { type?: string; enum?: string[]; description?: string };
-			status: { type?: string; enum?: string[]; description?: string };
-		};
-	};
-	const action = schema.properties.action;
-	const status = schema.properties.status;
-
-	expect(action.type).toBe("string");
-	expect(action.enum).toEqual(["list", "set", "add", "update", "clear"]);
-	expect(action.description).toContain('"list" shows items');
-	expect(action.description).toContain('"update" changes one item by id');
-	expect(status?.type).toBe("string");
-	expect(status?.enum).toEqual(["pending", "in_progress", "done", "blocked"]);
-	expect(status?.description).toContain('"pending" = not started');
-	expect(status?.description).toContain('"blocked" = cannot proceed');
-});
-
-// ─── parseItems (via set/add) ───────────────────────────────────────────────
-
-describe("todo actions", () => {
-	test("list on empty returns (no todos)", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		const result = await run(host.execute, { action: "list" });
-		expect(text(result)).toBe("(no todos)");
-	});
-
-	test("set creates items from newline text", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		const result = await run(host.execute, {
-			action: "set",
-			items: "alpha\nbravo\ncharlie",
-		});
-		const out = text(result);
-		expect(out).toContain("Todos 0/3 done");
-		expect(out).toContain("○ 1. alpha");
-		expect(out).toContain("○ 2. bravo");
-		expect(out).toContain("○ 3. charlie");
-	});
-
-	test("set creates items from numbered list", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		const result = await run(host.execute, {
-			action: "set",
-			items: "1. alpha\n2. bravo",
-		});
-		expect(text(result)).toContain("○ 1. alpha");
-	});
-
-	test("set creates items from bullet list", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		const result = await run(host.execute, {
-			action: "set",
-			items: "- alpha\n* bravo",
-		});
-		expect(text(result)).toContain("○ 1. alpha");
-		expect(text(result)).toContain("○ 2. bravo");
-	});
-
-	test("set ignores empty lines", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		const result = await run(host.execute, {
-			action: "set",
-			items: "alpha\n\nbravo\n  \ncharlie",
-		});
-		expect(text(result)).toContain("Todos 0/3 done");
-	});
-
-	test("set with empty items returns error", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		const result = await run(host.execute, { action: "set", items: "" });
-		expect(result.isError).toBe(true);
-		expect(text(result)).toContain("non-empty");
-	});
-
-	test("set with only whitespace returns error", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		const result = await run(host.execute, { action: "set", items: "  \n  " });
-		expect(result.isError).toBe(true);
-	});
-
-	test("set resets ids on re-set", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		await run(host.execute, { action: "set", items: "first\nsecond" });
-		const result = await run(host.execute, { action: "set", items: "new" });
-		expect(text(result)).toContain("○ 1. new");
-		expect(text(result)).toContain("Todos 0/1 done");
-	});
-
-	test("add appends items", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		await run(host.execute, { action: "set", items: "alpha" });
-		const result = await run(host.execute, {
-			action: "add",
-			items: "bravo\ncharlie",
-		});
-		const out = text(result);
-		expect(out).toContain("○ 1. alpha");
-		expect(out).toContain("○ 2. bravo");
-		expect(out).toContain("○ 3. charlie");
-		expect(out).toContain("Todos 0/3 done");
-	});
-
-	test("add with ids continuing sequence", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		await run(host.execute, { action: "set", items: "first\nsecond\nthird" });
-		const result = await run(host.execute, { action: "add", items: "fourth" });
-		expect(text(result)).toContain("○ 4. fourth");
-	});
-
-	test("add with empty items returns error", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		const result = await run(host.execute, { action: "add", items: "" });
-		expect(result.isError).toBe(true);
-		expect(text(result)).toContain("non-empty");
-	});
-
-	test("update changes status", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		await run(host.execute, { action: "set", items: "alpha\nbravo" });
-		const result = await run(host.execute, {
-			action: "update",
-			id: 1,
-			status: "done",
-		});
-		const out = text(result);
-		expect(out).toContain("● 1. alpha");
-		expect(out).toContain("○ 2. bravo");
-		expect(out).toContain("Todos 1/2 done");
-	});
-
-	test("update changes text", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		await run(host.execute, { action: "set", items: "old name" });
-		const result = await run(host.execute, {
-			action: "update",
-			id: 1,
-			text: "new name",
-		});
-		expect(text(result)).toContain("○ 1. new name");
-	});
-
-	test("update changes status and text together", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		await run(host.execute, { action: "set", items: "alpha" });
-		const result = await run(host.execute, {
-			action: "update",
-			id: 1,
-			status: "blocked",
-			text: "alpha (waiting)",
-		});
-		const out = text(result);
-		expect(out).toContain("⊘ 1. alpha (waiting)");
-		expect(out).toContain("Todos 0/1 done");
-	});
-
-	test("opening a new in_progress closes the previous one", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		await run(host.execute, { action: "set", items: "a\nb\nc" });
-		await run(host.execute, { action: "update", id: 1, status: "in_progress" });
-		const result = await run(host.execute, {
-			action: "update",
-			id: 2,
-			status: "in_progress",
-		});
-		const out = text(result);
-		expect(out).toContain("● 1. a"); // auto-closed to done
-		expect(out).toContain("◐ 2. b"); // now active
-		expect(out).toContain("○ 3. c");
-		expect(out).toContain("Todos 1/3 done");
-	});
-
-	test("opening a later item cascade-closes skipped pending items", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		await run(host.execute, { action: "set", items: "a\nb\nc\nd" });
-		// Jump straight to id 4 without opening 1-3; they should all auto-close.
-		const result = await run(host.execute, {
-			action: "update",
-			id: 4,
-			status: "in_progress",
-		});
-		const out = text(result);
-		expect(out).toContain("● 1. a");
-		expect(out).toContain("● 2. b");
-		expect(out).toContain("● 3. c");
-		expect(out).toContain("◐ 4. d");
-		expect(out).toContain("Todos 3/4 done");
-	});
-
-	test("cascade-close leaves a blocked earlier item untouched", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		await run(host.execute, { action: "set", items: "a\nb\nc" });
-		await run(host.execute, { action: "update", id: 1, status: "blocked" });
-		const result = await run(host.execute, {
-			action: "update",
-			id: 3,
-			status: "in_progress",
-		});
-		const out = text(result);
-		expect(out).toContain("⊘ 1. a"); // still blocked, not force-closed
-		expect(out).toContain("● 2. b"); // pending -> done
-		expect(out).toContain("◐ 3. c");
-	});
-
-	test("update unknown id returns error", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		const result = await run(host.execute, {
-			action: "update",
-			id: 999,
-			status: "done",
-		});
-		expect(result.isError).toBe(true);
-		expect(text(result)).toContain("999");
-	});
-
-	test("update without status or text does nothing", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		await run(host.execute, { action: "set", items: "unchanged" });
-		const result = await run(host.execute, { action: "update", id: 1 });
-		expect(text(result)).toContain("○ 1. unchanged");
-	});
-
-	test("clear empties list", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		await run(host.execute, { action: "set", items: "alpha\nbravo" });
-		const result = await run(host.execute, { action: "clear" });
-		expect(text(result)).toContain("Todos cleared");
-		// next list should show empty
-		const list = await run(host.execute, { action: "list" });
-		expect(text(list)).toBe("(no todos)");
-	});
-
-	test("clear resets id counter", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		await run(host.execute, { action: "set", items: "alpha\nbravo\ncharlie" });
-		await run(host.execute, { action: "clear" });
-		const result = await run(host.execute, { action: "set", items: "new" });
-		expect(text(result)).toContain("○ 1. new");
-	});
-
-	test("unknown action returns error", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		const result = await run(host.execute, { action: "bogus" });
-		expect(result.isError).toBe(true);
-		expect(text(result)).toContain("Unknown action");
-	});
-
-	test("all status glyphs render correctly", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		await run(host.execute, { action: "set", items: "a\nb\nc\nd" });
-		// Open id 2 first (cascade-closes nothing earlier we assert on), then set
-		// the others directly so each glyph is exercised without cascade interfering.
-		await run(host.execute, { action: "update", id: 2, status: "in_progress" });
-		await run(host.execute, { action: "update", id: 1, status: "pending" });
-		await run(host.execute, { action: "update", id: 3, status: "done" });
-		await run(host.execute, { action: "update", id: 4, status: "blocked" });
-		const out = text(await run(host.execute, { action: "list" }));
-		expect(out).toContain("○ 1. a");
-		expect(out).toContain("◐ 2. b");
-		expect(out).toContain("● 3. c");
-		expect(out).toContain("⊘ 4. d");
-		expect(out).toContain("Todos 1/4 done");
-	});
-});
-
-// ─── Persistence ────────────────────────────────────────────────────────────
-
-describe("persistence", () => {
-	type AppendCall = { type: string; data: unknown };
-	test("set persists todos", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		host.appendCalls.length = 0;
-		await run(host.execute, { action: "set", items: "alpha\nbravo" });
-		expect(host.appendCalls.length).toBe(1);
-		const ac0 = host.appendCalls[0] as AppendCall;
-		expect(ac0.type).toBe("todo-state");
-		const data = ac0.data as {
-			todos: Array<{ id: number; text: string; status: string }>;
-			nextTodoId: number;
-		};
-		expect(data.todos).toHaveLength(2);
-		expect(data.nextTodoId).toBe(3);
-	});
-
-	test("add persists todos", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		await run(host.execute, { action: "set", items: "alpha" });
-		host.appendCalls.length = 0;
-		await run(host.execute, { action: "add", items: "bravo" });
-		expect(host.appendCalls.length).toBe(1);
-	});
-
-	test("update persists todos", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		await run(host.execute, { action: "set", items: "alpha" });
-		host.appendCalls.length = 0;
-		await run(host.execute, { action: "update", id: 1, status: "done" });
-		expect(host.appendCalls.length).toBe(1);
-	});
-
-	test("clear persists", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		await run(host.execute, { action: "set", items: "alpha" });
-		host.appendCalls.length = 0;
-		await run(host.execute, { action: "clear" });
-		expect(host.appendCalls.length).toBe(1);
-		const data = (host.appendCalls[0] as AppendCall).data as {
-			todos: Array<unknown>;
-			nextTodoId: number;
-		};
-		expect(data.todos).toEqual([]);
-		expect(data.nextTodoId).toBe(1);
-	});
-});
-
-// ─── Session restore ────────────────────────────────────────────────────────
-
-describe("restore", () => {
-	test("restores todos from last todo-state entry", async () => {
-		const host = makeHost([
-			{
-				type: "custom",
-				customType: "todo-state",
-				data: {
-					todos: [{ id: 1, text: "restored", status: "done" }],
-					nextTodoId: 2,
-				},
-			},
-		]);
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		const result = await run(host.execute, { action: "list" });
-		expect(text(result)).toContain("● 1. restored");
-		expect(text(result)).toContain("Todos 1/1 done");
-	});
-
-	test("restores nextTodoId so new items continue sequence", async () => {
-		const host = makeHost([
-			{
-				type: "custom",
-				customType: "todo-state",
-				data: {
-					todos: [{ id: 5, text: "existing", status: "pending" }],
-					nextTodoId: 6,
-				},
-			},
-		]);
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		const result = await run(host.execute, { action: "add", items: "new" });
-		expect(text(result)).toContain("○ 6. new");
-	});
-
-	test("restores nextTodoId from max id when nextTodoId missing", async () => {
-		const host = makeHost([
-			{
-				type: "custom",
-				customType: "todo-state",
-				data: {
-					todos: [
-						{ id: 3, text: "old", status: "done" },
-						{ id: 7, text: "newer", status: "pending" },
-					],
-				},
-			},
-		]);
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		const result = await run(host.execute, { action: "add", items: "next" });
-		expect(text(result)).toContain("○ 8. next");
-	});
-
-	test("ignores non-todo-state entries", async () => {
-		const host = makeHost([
-			{ type: "message", data: "hello" },
-			{ type: "custom", customType: "other-thing", data: {} },
-			{
-				type: "custom",
-				customType: "todo-state",
-				data: {
-					todos: [{ id: 1, text: "real", status: "pending" }],
-					nextTodoId: 2,
-				},
-			},
-		]);
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		const result = await run(host.execute, { action: "list" });
-		expect(text(result)).toContain("○ 1. real");
-	});
-
-	test("no todo-state entries starts empty", async () => {
-		const host = makeHost([{ type: "message", data: "hello" }]);
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		const result = await run(host.execute, { action: "list" });
-		expect(text(result)).toBe("(no todos)");
-	});
-
-	test("empty entries list starts empty", async () => {
-		const host = makeHost([]);
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		const result = await run(host.execute, { action: "list" });
-		expect(text(result)).toBe("(no todos)");
-	});
-
-	test("restore with empty todos array works", async () => {
-		const host = makeHost([
-			{
-				type: "custom",
-				customType: "todo-state",
-				data: { todos: [], nextTodoId: 1 },
-			},
-		]);
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		const result = await run(host.execute, { action: "list" });
-		expect(text(result)).toBe("(no todos)");
-	});
-});
-
-// ─── Skip-guard ─────────────────────────────────────────────────────────────────────
-
-describe("skip-guard on marking done", () => {
-	test("warns when marking a later item done with earlier pending items", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		await run(host.execute, { action: "set", items: "a\nb\nc\nd" });
-		// Mark items 1 and 4 done, leaving 2 and 3 pending
-		await run(host.execute, { action: "update", id: 1, status: "done" });
-		const result = await run(host.execute, { action: "update", id: 4, status: "done" });
-		const out = text(result);
-		expect(out).toContain("\u26a0 Earlier items still incomplete");
-		expect(out).toContain("#2 (b)");
-		expect(out).toContain("#3 (c)");
-		expect(out).toContain("Mark each done or blocked before proceeding");
-	});
-
-	test("no warning when all earlier items are done", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		await run(host.execute, { action: "set", items: "a\nb\nc" });
-		await run(host.execute, { action: "update", id: 1, status: "done" });
-		await run(host.execute, { action: "update", id: 2, status: "done" });
-		const result = await run(host.execute, { action: "update", id: 3, status: "done" });
-		expect(text(result)).not.toContain("\u26a0");
-	});
-
-	test("no warning when marking the first item done", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		await run(host.execute, { action: "set", items: "a\nb" });
-		const result = await run(host.execute, { action: "update", id: 1, status: "done" });
-		expect(text(result)).not.toContain("\u26a0");
-	});
-
-	test("no warning when earlier items are blocked (only pending/in_progress trigger)", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		await run(host.execute, { action: "set", items: "a\nb\nc" });
-		await run(host.execute, { action: "update", id: 1, status: "blocked" });
-		await run(host.execute, { action: "update", id: 2, status: "done" });
-		const result = await run(host.execute, { action: "update", id: 3, status: "done" });
-		// blocked is an explicit decision, not incomplete — no warning
-		expect(text(result)).not.toContain("\u26a0");
-	});
-
-	test("warns about in_progress items too (not just pending)", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		await run(host.execute, { action: "set", items: "a\nb\nc" });
-		await run(host.execute, { action: "update", id: 1, status: "in_progress" });
-		// Mark item 3 done while item 1 is still in_progress
-		const result = await run(host.execute, { action: "update", id: 3, status: "done" });
-		const out = text(result);
-		expect(out).toContain("\u26a0");
-		expect(out).toContain("#1 (a)");
-	});
-
-	test("no skip-guard on in_progress (only on done)", async () => {
-		// in_progress uses cascade-close instead, which is different behavior
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		await run(host.execute, { action: "set", items: "a\nb\nc" });
-		const result = await run(host.execute, { action: "update", id: 3, status: "in_progress" });
-		// Should cascade-close, not warn
-		expect(text(result)).not.toContain("\u26a0");
-		expect(text(result)).toContain("\u25cf 1. a"); // cascade-closed to done
-		expect(text(result)).toContain("\u25cf 2. b");
-	});
-});
-
-// ─── Unordered lists (ordered:false) ────────────────────────────────────
-
-describe("unordered lists", () => {
-	test("ordered:false opening a later item does NOT cascade-close earlier ones", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		await run(host.execute, { action: "set", items: "a\nb\nc", ordered: false });
-		const result = await run(host.execute, { action: "update", id: 3, status: "in_progress" });
-		// Earlier items stay pending — no silent completion.
-		expect(text(result)).toContain("\u25cb 1. a");
-		expect(text(result)).toContain("\u25cb 2. b");
-		expect(text(result)).toContain("\u25d0 3. c");
-	});
-
-	test("ordered:false marking a later item done does NOT warn about earlier ones", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		await run(host.execute, { action: "set", items: "a\nb\nc", ordered: false });
-		const result = await run(host.execute, { action: "update", id: 3, status: "done" });
-		expect(text(result)).not.toContain("\u26a0");
-	});
-
-	test("defaults to ordered (cascade-close) when ordered omitted", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		await run(host.execute, { action: "set", items: "a\nb\nc" });
-		const result = await run(host.execute, { action: "update", id: 3, status: "in_progress" });
-		expect(text(result)).toContain("\u25cf 1. a"); // cascade-closed to done
-	});
-
-	test("ordered flag persists and restores", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		host.appendCalls.length = 0;
-		await run(host.execute, { action: "set", items: "a\nb", ordered: false });
-		const data = host.appendCalls[0]?.data as { ordered?: boolean };
-		expect(data.ordered).toBe(false);
-
-		// Restore into a fresh host and confirm cascade stays disabled.
-		delete (globalThis as { __pixOnce?: WeakMap<object, Set<string>> }).__pixOnce;
-		const host2 = makeHost([
-			{
-				type: "custom",
-				customType: "todo-state",
-				data: {
-					todos: [
-						{ id: 1, text: "a", status: "pending" },
-						{ id: 2, text: "b", status: "pending" },
-					],
-					nextTodoId: 3,
-					ordered: false,
-				},
-			},
-		]);
-		registerTodo(host2.pi);
-		await host2.emit("session_start", {}, { sessionManager: host2.sessionManager });
-		const result = await run(host2.execute, { action: "update", id: 2, status: "in_progress" });
-		expect(text(result)).toContain("\u25cb 1. a"); // NOT cascade-closed
-	});
-});
-
-// ─── Turn-based reminder ────────────────────────────────────────────────────────────
-
-describe("turn-based todo reminder", () => {
-	test("injects reminder every 10 turns when incomplete items exist", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		await run(host.execute, { action: "set", items: "a\nb" });
-
-		// Simulate 10 turns — only the 10th should inject
-		for (let i = 1; i <= 9; i++) {
-			const result = await host.emit("before_agent_start", { systemPrompt: "base" });
-			// before_agent_start returns undefined when no injection
-			expect(result).toBeUndefined();
-		}
-		// 10th turn should inject
-		const result = await host.emit("before_agent_start", { systemPrompt: "base" });
-		expect(result).toBeDefined();
-		const prompt = (result as { systemPrompt: string }).systemPrompt;
-		expect(prompt).toContain("base");
-		expect(prompt).toContain("Todo reminder");
-		expect(prompt).toContain("1. a");
-		expect(prompt).toContain("2. b");
-	});
-
-	test("does not inject when no todos exist", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-
-		for (let i = 1; i <= 10; i++) {
-			const result = await host.emit("before_agent_start", { systemPrompt: "base" });
-			expect(result).toBeUndefined();
-		}
-	});
-
-	test("does not inject when all items are done", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		await run(host.execute, { action: "set", items: "a" });
-		await run(host.execute, { action: "update", id: 1, status: "done" });
-
-		for (let i = 1; i <= 10; i++) {
-			const result = await host.emit("before_agent_start", { systemPrompt: "base" });
-			expect(result).toBeUndefined();
-		}
-	});
-});
-
-describe("renderTodoLines (colored TUI render)", () => {
-	const items: TodoItem[] = [
-		{ id: 1, text: "alpha", status: "done" },
-		{ id: 2, text: "bravo", status: "in_progress" },
-		{ id: 3, text: "charlie", status: "pending" },
-		{ id: 4, text: "delta", status: "blocked" },
-	];
-
-	test("empty list renders muted placeholder", () => {
-		expect(renderTodoLines([], tagTheme)).toBe("[muted](no todos)[/]");
-	});
-
-	test("colors each card cell by status (glyph + body one unit)", () => {
-		const out = renderTodoLines(items, tagTheme);
-		// Cards are padded cells colored as a whole; assert the tint wraps each card
-		// body (glyph-agnostic — glyph codepoint comes from the icon catalog/mode).
-		expect(out).toMatch(/\[success\][^\n]*alpha/); // done card success
-		expect(out).toMatch(/<b>\[accent\][^\n]*bravo[^\n]*<\/b>/); // in_progress bold+accent
-		expect(out).toMatch(/\[text\][^\n]*charlie/); // pending card white (text)
-		expect(out).toMatch(/\[error\][^\n]*delta/); // blocked card error
-	});
-
-	test("renders a header row with one column per status", () => {
-		const out = renderTodoLines(items, tagTheme);
-		expect(out).toContain("To Do (1)");
-		expect(out).toContain("In Progress (1)");
-		expect(out).toContain("Blocked (1)");
-		expect(out).toContain("Done (1)");
-	});
-});
-
-describe("todo card layout", () => {
-	test("uses the self-rendered shell so the compact checkmark has no leading space", () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		expect(host.renderShell).toBe("self");
-	});
-
-	test("shows the todo <action> title while open, empty once collapsed", () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		// Open card: title + action visible.
-		const open = host.renderCall({ action: "set" }, tagTheme, { state: {}, expanded: false });
-		expect(open.render(80).join("\n")).toContain("todo");
-		expect(open.render(80).join("\n")).toContain("set");
-		// Collapsed card: call row hides so the summary row is the only line.
-		const closed = host.renderCall({ action: "set" }, tagTheme, {
-			state: { collapsed: true },
-			expanded: false,
-		});
-		expect(closed.render(80).join("\n")).toBe("");
-	});
-
-	test("expanded mode restores a collapsed checklist", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		const result = await run(host.execute, { action: "set", items: "alpha\nbravo" });
-		const rendered = host
-			.render(result, { expanded: true }, tagTheme, {
-				state: { collapsed: true },
-				invalidate: () => {},
-			})
-			.render(80)
-			.join("\n");
-
-		expect(rendered).toContain("alpha");
-		expect(rendered).toContain("[text]○ alpha"); // pending card, no id number
-		expect(rendered).not.toContain("[success]✓ [/] [toolTitle]<b>todo</b>[/]");
-		expect(rendered.split("\n")[0]).toBe(`[success]${"─".repeat(80)}[/]`);
-	});
-
-	test("opening a new todo card collapses the previously open one", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		const r1 = await run(host.execute, { action: "set", items: "a" });
-		const r2 = await run(host.execute, { action: "add", items: "b" });
-
-		// Card 1 renders open (not yet collapsed).
-		let invalidated1 = false;
-		const state1 = { collapsed: false } as { collapsed?: boolean };
-		host.render(r1, { expanded: false }, tagTheme, {
-			state: state1,
-			invalidate: () => {
-				invalidated1 = true;
-			},
-		});
-		expect(state1.collapsed).toBe(false);
-
-		// Card 2 renders open → it claims focus and collapses card 1.
-		const state2 = { collapsed: false } as { collapsed?: boolean };
-		host.render(r2, { expanded: false }, tagTheme, {
-			state: state2,
-			invalidate: () => {},
-		});
-		expect(state1.collapsed).toBe(true); // previous card force-collapsed
-		expect(invalidated1).toBe(true); // and re-rendered
-		expect(state2.collapsed).toBe(false); // newest stays open
-	});
-
-	test("failed todo actions render their exact error", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		const result = await run(host.execute, { action: "update", id: 99, status: "done" });
-		const rendered = host
-			.render(result, { expanded: false }, tagTheme, {
-				state: { collapsed: true },
-				invalidate: () => {},
-			})
-			.render(80)
-			.join("\n")
-			.trimEnd();
-
-		expect(rendered.split("\n")[0]).toBe(`[error]${"─".repeat(80)}[/]`);
-		expect(rendered).toContain("No todo with id 99.");
-	});
-
-	test("a collapsed result is exactly one shared-style line", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		await run(host.execute, { action: "set", items: "foundation\ntodo renderer" });
-		const result = await run(host.execute, { action: "update", id: 1, status: "done" });
-		const activeResult = await run(host.execute, {
-			action: "update",
-			id: 2,
-			status: "in_progress",
-		});
-		const lines = host
-			.render(activeResult, { expanded: false }, tagTheme, {
-				state: { collapsed: true },
-				invalidate: () => {},
-			})
-			.render(120);
-
-		expect(result.details).toBeDefined();
-		expect(lines).toHaveLength(1);
-		expect(lines[0]).not.toContain("────");
-		expect(lines[0]?.trimEnd()).toBe(
-			"[success]✓ [/] [toolTitle]<b>todo</b>[/] [dim]#2 todo renderer[/] [muted]·[/] [muted]1/2 done[/]",
-		);
-	});
-});
-
-describe("renderResult snapshot isolation", () => {
-	test("successful results carry immutable snapshots", async () => {
-		const host = makeHost();
-		registerTodo(host.pi);
-		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		const original = await run(host.execute, { action: "set", items: "alpha\nbravo" });
-		await run(host.execute, { action: "set", items: "changed" });
-
-		const details = original.details as { snapshot: TodoItem[] };
-		expect(details.snapshot.map((item) => item.text)).toEqual(["alpha", "bravo"]);
-		const rendered = host
-			.render(original, { expanded: true }, tagTheme, {
-				state: {},
-				invalidate: () => {},
-			})
-			.render(80)
-			.join("\n");
-		expect(rendered).toContain("alpha");
-		expect(rendered).toContain("bravo");
-		expect(rendered).not.toContain("changed");
-	});
-});
-
-describe("renderTodoSummaryLine (collapsed one-liner)", () => {
-	test("empty list renders a compact tool row", () => {
-		expect(renderTodoSummaryLine([], tagTheme)).toBe(
-			"[success]✓ [/] [toolTitle]<b>todo</b>[/] [dim]empty[/]",
-		);
-	});
-
-	test("uses warning status when work is blocked", () => {
-		const items: TodoItem[] = [{ id: 1, text: "Need approval", status: "blocked" }];
-		expect(renderTodoSummaryLine(items, tagTheme)).toBe(
-			"[warning]⚠ [/] [toolTitle]<b>todo</b>[/] [dim]checklist[/] [muted]·[/] [muted]0/1 done · 1 blocked[/]",
-		);
-	});
-
-	test("renders active work and progress in one row", () => {
-		const items: TodoItem[] = [
-			{ id: 1, text: "a", status: "done" },
-			{ id: 2, text: "b", status: "in_progress" },
-		];
-		expect(renderTodoSummaryLine(items, tagTheme)).toBe(
-			"[success]✓ [/] [toolTitle]<b>todo</b>[/] [dim]#2 b[/] [muted]·[/] [muted]1/2 done[/]",
-		);
-	});
-});