@fyeeme/pi-todo 1.0.0 → 1.0.1

package/CHANGELOG.md

@@ -1,6 +1,25 @@
 # Changelog
 
-## [Unreleased]
+## [1.0.1] - 2026-09-12
+
+### Breaking Changes
+
+- Cognitive-neutral refactor: pi-todo is now a neutral stateful notepad — statuses change only through explicit ops, and the list never steers the agent. Removed: eager-todo `promptGuidelines` (no more system-prompt nudges to plan first), the stop-reminder nag loop (`checkCompletion` / `⚠ N incomplete todos` transcript box / 3-attempt auto-continuation cycle), and the manual-edit `<system-reminder>` injection after `/todo` mutations. Motivation: the reminder loop plus the "or mark them complete" wording gave the agent a cheap escape hatch (tick boxes to silence the nag), and the plan-first nudges encouraged executing shallow 5–10-word labels without re-derivation.
+- Removed `promptSnippet` from the tool definition (host docs allow omission): the tool no longer appears in the default system prompt's `Available tools` section, making the "no prompt steering" claim literal.
+- Removed the single-`in_progress` invariant and the auto-promotion pointer (`normalizeInProgressTask`): `start` no longer demotes other `in_progress` tasks, completions never auto-promote a pending task, and multiple `in_progress` tasks are allowed. The five-status enum is unchanged (pi-goal's progress counting is unaffected).
+- Removed the unused subagent description matcher (`todoMatchesAnyDescription`) and the `openTasks` helper, plus the now-parameterless `isMatched` viewport pipeline (`selectCollapsedTodos(tasks, cap)`).
+
+### Changed
+
+- Mutation results prepend a `Changed:` block listing every status transition (`- task [pending → blocked] (blocked: note) (phase)`), so a write is confirmed per-task even when the summary folds on lists over 20 tasks.
+- Error results no longer fold: the thrown batch-error message always carries the full unchanged list, restoring the documented retry contract on big lists.
+- The transcript renderer keeps the earliest open-work phase expanded (the active phase the summary reports) instead of relying on the removed auto-promotion pointer; stale pointer wording in renderer comments updated.
+- Tool description (`todo.md`) reduced to mechanical documentation (ops, anatomy, lookup-key rules); all behavioral steering wording removed, including the earlier anti-laziness rules (evidence-gated `done`, re-plan license) — with the nag loop gone their premise no longer holds, and the notepad stays neutral.
+- `formatSummary`'s worked-ahead note no longer references the removed auto-advancing pointer.
+- Markdown round-trip no longer normalizes statuses on parse (`markdownToPhases`): `/todo edit` and `import` now restore statuses exactly as written.
+- `formatSummary` folds its per-task dumps on mutation results once the list exceeds 20 tasks: remaining items capped at the first 10 with a `… N more open — call view` hint plus a single "Full checklist omitted" line. `view` (readOnly) still echoes the whole list. On big lists every `done`/`start` previously re-flooded the model context with the full checklist.
+- `execute` clones phases 4 times per mutation instead of 8 (ownership handoff to the closure; persist/broadcast make their own entry-shaped snapshots); `getCompletionTransitions` generalized to `getStatusTransitions` whose result is now rendered instead of only feeding `completedTasks`.
+- pi-goal's `goal-todo-context.md` no longer references the removed pointer/"stale in_progress" semantics (paired fix in @fyeeme/pi-goal).
 
 ## [1.0.0] - 2026-09-09
 

package/README.md

@@ -2,7 +2,9 @@
 
 Phased todo lists for [pi](https://github.com/earendil-works/pi-coding-agent) — the oh-my-pi todo tool migrated to a pi extension.
 
-The agent gets a `todo` tool: a phased task list (phases → tasks with lifecycle statuses) persisted with the session. You get a `/todo` command, a transcript reminder when the agent stops with unfinished work, and a `todo_updated` event other extensions can consume (pi-goal uses it to attach live progress state to goal continuations).
+The agent gets a `todo` tool: a phased task list (phases → tasks with lifecycle statuses) persisted with the session. You get a `/todo` command and a `todo_updated` event other extensions can consume (pi-goal uses it to attach live progress state to goal continuations).
+
+The extension is a **cognitive-neutral notepad**: statuses change only through explicit ops, and none of the omp behavior-engineering survives — no system-prompt nudges, no stop-time nag loop, no hidden reminders. The list records state; it never steers the agent.
 
 ## Install
 
@@ -19,7 +21,7 @@ Nine operations over `phases: [{ phase, items: string[] }]` state:
 | `op`       | Fields                    | Effect                                                    |
 | ---------- | ------------------------- | --------------------------------------------------------- |
 | `init`     | `list` (or flat `items`)  | Replace the whole list; all tasks start `pending`          |
-| `start`    | `task`                    | Mark `in_progress`; demotes every other `in_progress` task |
+| `start`    | `task`                    | Mark `in_progress` (explicit; other tasks untouched)      |
 | `done`     | `task` or `phase`         | Mark `completed`                                           |
 | `drop`     | `task` or `phase`         | Mark `abandoned` (never deleted)                           |
 | `block`    | `task` or `phase`, `reason?` | Park open work awaiting external input; one-line reason |
@@ -28,7 +30,7 @@ Nine operations over `phases: [{ phase, items: string[] }]` state:
 | `append`   | `phase`, `items`          | Add `pending` tasks; lazily creates the phase              |
 | `view`     | —                         | Read-only snapshot                                         |
 
-Semantics kept verbatim from oh-my-pi: batch-atomic duplicate rejection (a failing op applies nothing), a single `in_progress` invariant with the earliest pending task auto-promoted on every mutation, `block` never reopens finished work, `view` never writes.
+Semantics ported from oh-my-pi: batch-atomic duplicate rejection (a failing op applies nothing), `block` never reopens finished work, `view` never writes. Deliberate deviation: the single-`in_progress` invariant and the auto-promotion pointer are removed — statuses are set only by explicit ops, and multiple `in_progress` tasks are allowed.
 
 ## Command
 
@@ -47,12 +49,6 @@ The full oh-my-pi `/todo` verb set:
 /todo rm     [<task|phase>]        Remove task/phase/all
 ```
 
-Every mutation commits a `<system-reminder>` hidden message telling the agent the user manually modified the list (with explicit intent notes after removals, so it never rebuilds cleared items).
-
-## Stop reminders
-
-When an agent run ends while tasks are still `pending`/`in_progress`, oh-my-pi's reminder loop kicks in: a hidden `<system-reminder>` message ("You stopped with N incomplete todo item(s)... (Reminder X/3)") is queued as a follow-up turn so the agent continues or marks work done, and a `⚠ N incomplete todos - reminder X/3` note is anchored in the transcript. The cycle allows 3 reminders, restarts on each new user prompt, and stays silent when the assistant's last line is a question to the user (the ball is in your court) or when only `blocked` tasks remain — those are parked awaiting external input.
-
 ## Event contract
 
 After every successful mutation:
@@ -76,9 +72,12 @@ Source: `oh-my-pi/packages/coding-agent/src/tools/todo.ts` (plus reminder, slash
 | omp surface                                | Status in pi-todo                                        |
 | ------------------------------------------ | -------------------------------------------------------- |
 | mid-run todo nudge (tool-choice queue)      | Dropped — omp host-internal                               |
-| eager-todo / prewalk system-prompt arming   | Replaced by `promptGuidelines` on the tool definition     |
-| `/todo edit` + markdown round-trip          | Dropped — no host editor surface                          |
-| Sticky HUD / collapsed viewport / animations| Dropped — omp TUI-internal                                |
+| eager-todo / prewalk system-prompt arming   | Dropped — cognitive-neutral refactor (no prompt steering) |
+| Stop-reminder loop (checkCompletion, ×3 nag)| Dropped — cognitive-neutral refactor (no auto-continuation)|
+| Manual-edit `<system-reminder>` injection   | Dropped — cognitive-neutral refactor                      |
+| Single `in_progress` invariant / auto-promotion pointer | Dropped — statuses are explicit-only          |
+| `/todo edit` + markdown round-trip          | Kept — via `ctx.ui.editor`                                |
+| Sticky HUD / collapsed viewport / animations| Kept (viewport) in the transcript renderer; HUD dropped   |
 | Subagent todo-match lighting                | Dropped — no subagent HUD contract                        |
 | `todo.enabled` settings gate                | Dropped — no settings API by design: installed means active |
 

package/index.ts

@@ -6,9 +6,6 @@
  *   - packages/coding-agent/src/tools/todo.ts (TodoTool)     → src/tool.ts
  *   - packages/coding-agent/src/tools/todo.ts (renderer)     → src/render.ts
  *   - packages/coding-agent/src/prompts/tools/todo.md        → src/prompts/todo.md
- *   - packages/coding-agent/src/session/todo-tracker.ts (checkCompletion)
- *                                                            → agent_end reminder loop
- *   - packages/coding-agent/src/modes/components/todo-reminder.ts → reminder entry renderer
  *   - packages/coding-agent/src/modes/controllers/todo-command-controller.ts
  *                                                            → src/commands.ts
  *
@@ -28,65 +25,28 @@
  *                                         (missing-op inference before validation)
  *   concurrency: "exclusive"           → executionMode: "sequential"
  *   mergeCallAndResult renderer        → split renderCall/renderResult slots
- *   eager-todo system-prompt prewalk   → promptGuidelines on the tool definition
- *   developer-role injected messages   → pi.sendMessage display:false (custom
- *                                         role; both /todo edits and stop
- *                                         reminders)
- *   TodoTracker.checkCompletion        → agent_end handler: same reminder text,
- *                                         3-attempt cycle, question guard, and
- *                                         followUp-triggered continuation
- *   TodoReminderComponent (TUI box)    → "todo-reminder" entry renderer
- *                                         (transcript-anchored, same text)
- *   $EDITOR round-trip                 → ctx.ui.editor (Markdown round-trip)
- *   mid-run nudge (tool-choice queue)  → dropped (omp host-internal)
- *   subagent-match lighting            → dropped (omp host-internal provider)
  *
- * omp operation semantics are kept verbatim: batch-atomic duplicate
- * rejection, single in_progress invariant with earliest-pending auto-promotion,
- * drop = abandoned (never delete), block skips finished work, view is a read.
+ * Removed in the cognitive-neutral refactor (agent-steering logic, not
+ * bookkeeping): eager-todo promptGuidelines, the stop-reminder nag loop
+ * (checkCompletion / TodoReminderComponent), and the manual-edit
+ * `<system-reminder>` injection. The todo list is a neutral stateful notepad:
+ * statuses change only through explicit ops.
  *
  * Integration contract for other extensions:
  *   - `pi.events.emit("todo_updated", { phases })` after every successful
- *     mutation (never on view or failure)
- *   - stop reminders count pending + in_progress only (blocked is parked)
+ *     mutation (never on view or failure); full snapshot, five-status enum
+ *   - every mutation appends a "todo-phases" snapshot entry (pi-goal's
+ *     todo bridge and restore both read it)
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { Text, type Component } from "@earendil-works/pi-tui";
 import { createTodoCommand } from "./src/commands.ts";
-import { isAwaitingUserAnswer, type TodoItem, type TodoPhase } from "./src/state.ts";
+import { clonePhases, type TodoPhase } from "./src/state.ts";
 import { createTodoTool } from "./src/tool.ts";
-import {
-	TODO_PHASES_ENTRY_TYPE,
-	TODO_REMINDER_ENTRY_TYPE,
-	restorePhasesFromEntries,
-} from "./src/restore.ts";
-
-/** omp settings todo.remindersMax default (3) — extensions have no settings. */
-const REMINDERS_MAX = 3;
-
-interface AssistantTextLike {
-	role?: string;
-	content?: unknown;
-}
-
-function assistantText(message: AssistantTextLike): string {
-	if (!Array.isArray(message.content)) return "";
-	return message.content
-		.filter((block): block is { type: string; text?: string } =>
-			!!block && typeof block === "object" && (block as { type?: unknown }).type === "text",
-		)
-		.map(block => block.text ?? "")
-		.join("\n")
-		.trim();
-}
+import { TODO_PHASES_ENTRY_TYPE, restorePhasesFromEntries } from "./src/restore.ts";
 
 export default function piTodoExtension(pi: ExtensionAPI): void {
 	let phases: TodoPhase[] = [];
-	/** omp TodoTracker #reminderCount: reminders sent in the current cycle. */
-	let reminderCount = 0;
-	/** Last assistant reply text, for omp's awaiting-user-answer guard. */
-	let lastAssistantText = "";
 
 	const deps = {
 		getPhases: () => phases,
@@ -94,14 +54,10 @@ export default function piTodoExtension(pi: ExtensionAPI): void {
 			phases = next;
 		},
 		persist: (next: TodoPhase[]) => {
-			pi.appendEntry(TODO_PHASES_ENTRY_TYPE, { phases: clonePhasesForEntry(next) });
+			pi.appendEntry(TODO_PHASES_ENTRY_TYPE, { phases: clonePhases(next) });
 		},
 		broadcast: (next: TodoPhase[]) => {
-			pi.events.emit("todo_updated", { phases: clonePhasesForEntry(next) });
-		},
-		// omp #commit injects a developer system-reminder after user edits.
-		sendHiddenMessage: (content: string) => {
-			pi.sendMessage({ customType: "todo-user-edit", content, display: false });
+			pi.events.emit("todo_updated", { phases: clonePhases(next) });
 		},
 	};
 
@@ -118,105 +74,5 @@ export default function piTodoExtension(pi: ExtensionAPI): void {
 		// /fork or /tree navigation; getEntries() would let a later snapshot
 		// from an abandoned branch win the backward scan.
 		phases = restorePhasesFromEntries(ctx.sessionManager.getBranch());
-		reminderCount = 0;
-	});
-
-	pi.on("message_start", (event) => {
-		// omp resetCycle: a fresh user prompt starts a new reminder cycle.
-		if ((event.message as { role?: string }).role === "user") {
-			reminderCount = 0;
-		}
 	});
-
-	pi.on("agent_end", (event) => {
-		// Capture the last assistant text for the question guard BEFORE the
-		// reminder decision (omp checkCompletion sees the terminal message).
-		const messages = (event.messages ?? []) as AssistantTextLike[];
-		for (let i = messages.length - 1; i >= 0; i--) {
-			const message = messages[i];
-			if (message?.role === "assistant") {
-				lastAssistantText = assistantText(message);
-				break;
-			}
-		}
-		checkCompletion();
-	});
-
-	/** omp TodoTracker.checkCompletion: nag + auto-continue on open todos. */
-	function checkCompletion(): void {
-		if (reminderCount >= REMINDERS_MAX) return;
-		if (phases.length === 0) {
-			reminderCount = 0;
-			return;
-		}
-		const incompleteByPhase = phases
-			.map(phase => ({
-				name: phase.name,
-				tasks: phase.tasks.filter(task => task.status === "pending" || task.status === "in_progress"),
-			}))
-			.filter(phase => phase.tasks.length > 0);
-		const incomplete = incompleteByPhase.flatMap(phase => phase.tasks);
-		if (incomplete.length === 0) {
-			reminderCount = 0;
-			return;
-		}
-		// omp isAwaitingUserAnswer: the assistant ended by asking the user
-		// something — skip the reminder, the ball is in the user's court.
-		if (isAwaitingUserAnswer(lastAssistantText)) return;
-
-		reminderCount++;
-		const todoList = incompleteByPhase
-			.map(phase => `- ${phase.name}\n${phase.tasks.map(task => `  - ${task.content}`).join("\n")}`)
-			.join("\n");
-		const reminder =
-			`<system-reminder>\n` +
-			`You stopped with ${incomplete.length} incomplete todo item(s):\n${todoList}\n\n` +
-			`Please continue working on these tasks or mark them complete if finished.\n` +
-			`(Reminder ${reminderCount}/${REMINDERS_MAX})\n` +
-			`</system-reminder>`;
-		// omp: append developer message + scheduleAgentContinue.
-		pi.sendMessage(
-			{ customType: "todo-reminder", content: reminder, display: false },
-			{ triggerTurn: true, deliverAs: "followUp" },
-		);
-		pi.appendEntry(TODO_REMINDER_ENTRY_TYPE, {
-			count: incomplete.length,
-			attempt: reminderCount,
-			maxAttempts: REMINDERS_MAX,
-			todos: incomplete.map(task => ({ content: task.content, status: task.status })),
-		});
-	}
-
-	// omp TodoReminderComponent: warning box committed into the transcript —
-	// `⚠ N incomplete todos - reminder X/Y` + italic unchecked list.
-	pi.registerEntryRenderer<{
-		count?: number;
-		openCount?: number;
-		attempt?: number;
-		maxAttempts?: number;
-		todos?: TodoItem[];
-	}>(TODO_REMINDER_ENTRY_TYPE, (entry, _options, theme) => {
-		const data = entry.data;
-		const count = typeof data?.count === "number" ? data.count : typeof data?.openCount === "number" ? data.openCount : 0;
-		const attempt = typeof data?.attempt === "number" ? data.attempt : 1;
-		const maxAttempts = typeof data?.maxAttempts === "number" ? data.maxAttempts : REMINDERS_MAX;
-		const label = count === 1 ? "todo" : "todos";
-		const header = `⚠ ${count} incomplete ${label} - reminder ${attempt}/${maxAttempts}`;
-		const todos = Array.isArray(data?.todos) ? data.todos : [];
-		const list = todos.length > 0 ? `\n\n${theme.italic(todos.map(todo => `  ☐ ${todo.content}`).join("\n"))}` : "";
-		const component: Component = new Text(theme.fg("warning", header) + list, 0, 0);
-		return component;
-	});
-}
-
-/** Defensive clone for entries/events (omp TodoTracker.#clonePhases). */
-function clonePhasesForEntry(phases: TodoPhase[]): TodoPhase[] {
-	return phases.map(phase => ({
-		name: phase.name,
-		tasks: phase.tasks.map(task =>
-			task.blocker !== undefined
-				? { content: task.content, status: task.status, blocker: task.blocker }
-				: { content: task.content, status: task.status },
-		),
-	}));
 }

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@fyeeme/pi-todo",
-	"version": "1.0.0",
-	"description": "Phased todo list tool for pi — nine operations (init/start/done/rm/drop/block/unblock/append/view) over phase/task state persisted with the session, a /todo command, stop-time reminders for unfinished work, and a todo_updated event bus broadcast for other extensions.",
+	"version": "1.0.1",
+	"description": "Phased todo list tool for pi — nine operations (init/start/done/rm/drop/block/unblock/append/view) over phase/task state persisted with the session, a /todo command, and a todo_updated event bus broadcast for other extensions.",
 	"type": "module",
 	"license": "MIT",
 	"author": "fyeeme",

package/src/commands.ts

@@ -3,15 +3,14 @@
  *
  * Ported from oh-my-pi `todo-command-controller.ts` (+ its ACP helper in
  * slash-commands/helpers/todo.ts): view, edit, copy, export, import, append,
- * start, done, drop, rm, help — with quote-aware tokenizing, fuzzy
- * task/phase matching, and the developer system-reminder injection that tells
- * the agent the user manually modified the list.
+ * start, done, drop, rm, help — with quote-aware tokenizing and fuzzy
+ * task/phase matching. The omp developer system-reminder injection after
+ * manual edits was removed in the cognitive-neutral refactor.
  *
  * Host-internal surfaces map to pi:
  *   $EDITOR round-trip      → ctx.ui.editor (prefilled Markdown)
  *   clipboard copy          → printed (extension API has no clipboard write;
  *                             mirrors omp's own ACP fallback text)
- *   developer message       → pi.sendMessage display:false (custom role)
  *   user_todo_edit entry    → "todo-phases" snapshot (pi-todo's documented
  *                             entry contract, read back by restore and
  *                             pi-goal's todo bridge)
@@ -21,21 +20,18 @@ import { readFileSync, writeFileSync } from "node:fs";
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import {
 	type TodoItem,
+	type TodoOpEntry,
 	applyOpsToPhases,
+	clonePhases,
 	type TodoPhase,
 	markdownToPhases,
 	phasesToMarkdown,
 	resolveTodoMarkdownPath,
 } from "./state.ts";
+import { commitPhases, type TodoToolDeps } from "./tool.ts";
 
-export interface TodoCommandDeps {
-	getPhases(): TodoPhase[];
-	setPhases(phases: TodoPhase[]): void;
-	persist(phases: TodoPhase[]): void;
-	broadcast(phases: TodoPhase[]): void;
-	/** Latest event context so the reminder can reach the agent mid-session. */
-	sendHiddenMessage?(content: string): void;
-}
+/** Same dependency contract as the tool path (single write-back invariant). */
+export type TodoCommandDeps = TodoToolDeps;
 
 const USAGE = [
 	"Usage: /todo <verb> [args]",
@@ -144,24 +140,6 @@ function findTaskFuzzy(phases: TodoPhase[], query: string): TodoTaskMatch | unde
 	return undefined;
 }
 
-// =============================================================================
-// System reminder (omp buildSystemReminder) — tells the agent the list changed
-// =============================================================================
-
-function buildSystemReminder(action: string, phases: TodoPhase[], removed = false): string {
-	const md = phases.length === 0 ? "(empty)" : phasesToMarkdown(phases).trimEnd();
-	const lines = ["<system-reminder>", `The user manually modified the todo list (${action}).`];
-	if (removed) {
-		lines.push(
-			phases.length === 0
-				? "The user intentionally cleared the todo list. Do NOT recreate or re-populate it unless the user explicitly asks; continue the current request without a todo list."
-				: "The user intentionally removed the entries no longer shown below. Do NOT re-add them unless the user explicitly asks.",
-		);
-	}
-	lines.push("Current todo list:", "", md, "</system-reminder>");
-	return lines.join("\n");
-}
-
 // =============================================================================
 // Command handler
 // =============================================================================
@@ -226,15 +204,6 @@ function emit(ctx: ExtensionCommandContext, text: string, severity: "info" | "wa
 	console.error(text);
 }
 
-function commit(deps: TodoCommandDeps, nextPhases: TodoPhase[], action: string, opts?: { removed?: boolean }): void {
-	deps.setPhases(nextPhases);
-	deps.persist(nextPhases);
-	deps.broadcast(nextPhases);
-	// omp #commit step 3: inject the system reminder so the agent learns about
-	// the change next turn. Removals carry explicit intent (omp issue #5258).
-	deps.sendHiddenMessage?.(buildSystemReminder(action, nextPhases, opts?.removed ?? false));
-}
-
 function showCurrent(deps: TodoCommandDeps, ctx: ExtensionCommandContext): void {
 	const phases = deps.getPhases();
 	if (phases.length === 0) {
@@ -282,7 +251,7 @@ async function importFromFile(deps: TodoCommandDeps, ctx: ExtensionCommandContex
 		emit(ctx, `Could not parse ${source}:\n  ${errors.join("\n  ")}`, "error");
 		return;
 	}
-	commit(deps, phases, `/todo import ${source}`);
+	commitPhases(deps, phases);
 	const taskCount = phases.reduce((sum, p) => sum + p.tasks.length, 0);
 	emit(ctx, `Imported ${phases.length} phase(s), ${taskCount} task(s) from ${source}.`);
 }
@@ -305,7 +274,7 @@ function append(deps: TodoCommandDeps, ctx: ExtensionCommandContext, rest: strin
 		content = tokens.slice(1).join(" ");
 	}
 
-	const next = current.map(phase => ({ ...phase, tasks: phase.tasks.slice() }));
+	const next = clonePhases(current);
 	let targetPhase: TodoPhase;
 
 	if (phaseName) {
@@ -322,7 +291,7 @@ function append(deps: TodoCommandDeps, ctx: ExtensionCommandContext, rest: strin
 	const finalContent = titleCaseSentence(content);
 	targetPhase.tasks.push({ content: finalContent, status: "pending" });
 
-	commit(deps, next, `/todo append → ${targetPhase.name}`);
+	commitPhases(deps, next);
 	emit(ctx, `Appended to ${targetPhase.name}: ${finalContent}`);
 }
 
@@ -331,19 +300,30 @@ function start(deps: TodoCommandDeps, ctx: ExtensionCommandContext, rest: string
 		emit(ctx, "Usage: /todo start <task>", "error");
 		return;
 	}
-	const current = deps.getPhases();
-	const hit = findTaskFuzzy(current, rest);
+	const hit = findTaskFuzzy(deps.getPhases(), rest);
 	if (!hit) {
 		emit(ctx, `No task matched "${rest}". Use /todo to list current tasks.`, "error");
 		return;
 	}
-	const { phases, errors } = applyOpsToPhases(current, [{ op: "start", task: hit.task.content }]);
+	applyAndCommit(deps, ctx, [{ op: "start", task: hit.task.content }], `Started: ${hit.task.content}`);
+}
+
+/** Shared tail of every mutating verb: apply ops, commit on success, report.
+ *  A failing batch is discarded wholesale (state unchanged) and its errors
+ *  surface as one error line. */
+function applyAndCommit(
+	deps: TodoCommandDeps,
+	ctx: ExtensionCommandContext,
+	ops: TodoOpEntry[],
+	successMessage: string,
+): void {
+	const { phases, errors } = applyOpsToPhases(deps.getPhases(), ops);
 	if (errors.length > 0) {
 		emit(ctx, errors.join("; "), "error");
 		return;
 	}
-	commit(deps, phases, `/todo start ${hit.task.content}`);
-	emit(ctx, `Started: ${hit.task.content}`);
+	commitPhases(deps, phases);
+	emit(ctx, successMessage);
 }
 
 function mutateStatus(
@@ -357,37 +337,19 @@ function mutateStatus(
 	const trimmedArg = rest.trim();
 	if (!trimmedArg) {
 		// no-arg: apply to all
-		const { phases, errors } = applyOpsToPhases(current, [{ op }]);
-		if (errors.length > 0) {
-			emit(ctx, errors.join("; "), "error");
-			return;
-		}
-		commit(deps, phases, `/todo ${op} (all)`);
-		emit(ctx, `Marked all tasks ${target}.`);
+		applyAndCommit(deps, ctx, [{ op }], `Marked all tasks ${target}.`);
 		return;
 	}
 
 	const taskHit = findTaskFuzzy(current, trimmedArg);
 	if (taskHit) {
-		const { phases, errors } = applyOpsToPhases(current, [{ op, task: taskHit.task.content }]);
-		if (errors.length > 0) {
-			emit(ctx, errors.join("; "), "error");
-			return;
-		}
-		commit(deps, phases, `/todo ${op} ${taskHit.task.content}`);
-		emit(ctx, `Marked ${target}: ${taskHit.task.content}`);
+		applyAndCommit(deps, ctx, [{ op, task: taskHit.task.content }], `Marked ${target}: ${taskHit.task.content}`);
 		return;
 	}
 
 	const phaseHit = findPhaseFuzzy(current, trimmedArg);
 	if (phaseHit) {
-		const { phases, errors } = applyOpsToPhases(current, [{ op, phase: phaseHit.name }]);
-		if (errors.length > 0) {
-			emit(ctx, errors.join("; "), "error");
-			return;
-		}
-		commit(deps, phases, `/todo ${op} ${phaseHit.name}`);
-		emit(ctx, `Marked phase ${phaseHit.name} ${target}.`);
+		applyAndCommit(deps, ctx, [{ op, phase: phaseHit.name }], `Marked phase ${phaseHit.name} ${target}.`);
 		return;
 	}
 
@@ -398,30 +360,18 @@ function remove(deps: TodoCommandDeps, ctx: ExtensionCommandContext, rest: strin
 	const current = deps.getPhases();
 	const trimmedArg = rest.trim();
 	if (!trimmedArg) {
-		commit(deps, [], "/todo rm (all)", { removed: true });
+		commitPhases(deps, []);
 		emit(ctx, "Cleared all todos.");
 		return;
 	}
 	const taskHit = findTaskFuzzy(current, trimmedArg);
 	if (taskHit) {
-		const { phases, errors } = applyOpsToPhases(current, [{ op: "rm", task: taskHit.task.content }]);
-		if (errors.length > 0) {
-			emit(ctx, errors.join("; "), "error");
-			return;
-		}
-		commit(deps, phases, `/todo rm ${taskHit.task.content}`, { removed: true });
-		emit(ctx, `Removed: ${taskHit.task.content}`);
+		applyAndCommit(deps, ctx, [{ op: "rm", task: taskHit.task.content }], `Removed: ${taskHit.task.content}`);
 		return;
 	}
 	const phaseHit = findPhaseFuzzy(current, trimmedArg);
 	if (phaseHit) {
-		const { phases, errors } = applyOpsToPhases(current, [{ op: "rm", phase: phaseHit.name }]);
-		if (errors.length > 0) {
-			emit(ctx, errors.join("; "), "error");
-			return;
-		}
-		commit(deps, phases, `/todo rm ${phaseHit.name}`, { removed: true });
-		emit(ctx, `Removed phase: ${phaseHit.name}`);
+		applyAndCommit(deps, ctx, [{ op: "rm", phase: phaseHit.name }], `Removed phase: ${phaseHit.name}`);
 		return;
 	}
 	emit(ctx, `No task or phase matched "${trimmedArg}".`, "error");
@@ -451,7 +401,7 @@ async function editInEditor(deps: TodoCommandDeps, ctx: ExtensionCommandContext)
 		emit(ctx, `Could not parse Markdown:\n  ${errors.join("\n  ")}`, "error");
 		return;
 	}
-	commit(deps, parsed, "/todo edit");
+	commitPhases(deps, parsed);
 	const taskCount = parsed.reduce((sum, p) => sum + p.tasks.length, 0);
 	emit(ctx, `Todos updated from editor: ${parsed.length} phase(s), ${taskCount} task(s).`);
 }

package/src/prompts/todo.md

@@ -1,7 +1,5 @@
 **Tasks: verbatim content strings, NEVER auto-generated IDs; no "task-1"/"task-N". Pass content in `task`.**
 
-Each completion: earliest still-open task (phase order) auto-promotes to `in_progress`. Out-of-order completion may move pointer back to an earlier phase—expected; completed tasks NEVER revert.
-
 ## Operations
 
 |`op`|Fields|Effect|
@@ -11,7 +9,7 @@ Each completion: earliest still-open task (phase order) auto-promotes to `in_pro
 |`start`|`task`|Mark in progress|
 |`done`|`task` or `phase`|Mark completed|
 |`drop`|`task` or `phase`|Mark abandoned|
-|`block`|`task` or `phase`; optional `reason`|Mark blocked: open, awaiting external input; excluded from stop-time incomplete-todo reminder|
+|`block`|`task` or `phase`; optional `reason`|Mark blocked: open, awaiting external input|
 |`unblock`|`task` or `phase`|Blocked task → `pending`|
 |`rm`|optional `task` or `phase`|Remove task/phase; omit both → clear|
 |`append`|`phase`; `items: string[]`|Append tasks to phase; lazily creates phase|
@@ -24,21 +22,5 @@ Each completion: earliest still-open task (phase order) auto-promotes to `in_pro
 
 ## Rules
 
-- Mark tasks done immediately after finishing; complete phases in order.
-- NEVER make a todo call the turn's only tool call. Batch with real work: `init` with first reads/edits; each `done`/`start` with next action. Solo todo turns waste a round trip.
-- Waiting on something you can't act on—a user decision, another agent, external service: `block` task (optional `reason`); remains tracked but avoids stop reminder. `unblock` when actionable. If blocker agent-actionable, `append` an unblocking task instead.
-- Keep introduced `task`/`phase` strings stable.
+- Keep introduced `task`/`phase` strings stable: they are the lookup keys for every later op.
 - Lost exact task text: `view` echoes list; NEVER guess from memory.
-
-## Create a list
-
-- Task requires 3+ distinct steps.
-- User explicitly requests one.
-- User provides a set of tasks.
-- New instructions arrive mid-task: capture before proceeding.
-
-<critical>
-User gives multi-step plan—phased todo, numbered/bulleted checklist, or "N bugs/items/tasks":
-- MUST `init` every item as its own task before working.
-- Enumerate all; NEVER summarize into fewer tasks, sample "the important ones", drop items, or track the rest from memory.
-</critical>