pi-ui-extend 0.1.13 → 0.1.17

package/external/pi-tools-suite/src/todo/index.ts

@@ -1,16 +1,45 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { loadPiToolsSuiteConfig } from "../config.js";
 import { autoClearCompletedTodos } from "./state/auto-clear.js";
 import { loadPersistedPlan, syncPersistedPlan } from "./state/persistence.js";
 import { replayFromBranch } from "./state/replay.js";
 import { ACTIVE_STATUSES, isTaskBlocked, selectVisibleTasks } from "./state/selectors.js";
 import { getState, replaceState } from "./state/store.js";
-import { publishTodoState, registerTodosCommand, registerTodoTool } from "./todo.js";
+import { DEFAULT_PROMPT_GUIDELINES, DEFAULT_PROMPT_SNIPPET, publishTodoState, registerTodosCommand, registerTodoTool } from "./todo.js";
+import type { TaskMutationParams } from "./tool/types.js";
 
 const TODO_NUDGE_LIMIT = 8;
 const TODO_NUDGE_INITIAL_DELAY_MS = 5_000;
 const TODO_NUDGE_IDLE_RETRY_DELAY_MS = 100;
 const TODO_NUDGE_MAX_IDLE_ATTEMPTS = 40;
 const ASK_USER_TOOL_NAMES = new Set(["ask_user", "ask_user_question", "question"]);
+const TODO_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as const;
+
+type TodoThinkingLevel = (typeof TODO_THINKING_LEVELS)[number];
+type ModelLike = { reasoning?: boolean; thinkingLevelMap?: Partial<Record<TodoThinkingLevel, unknown | null>> };
+
+function isTodoThinkingLevel(value: unknown): value is TodoThinkingLevel {
+	return TODO_THINKING_LEVELS.includes(value as TodoThinkingLevel);
+}
+
+function getAvailableTodoThinkingLevels(model: unknown): TodoThinkingLevel[] {
+	const m = model as ModelLike | undefined;
+	if (!m?.reasoning) return ["off"];
+	const map = m.thinkingLevelMap;
+	return TODO_THINKING_LEVELS.filter((level) => level === "off" || map?.[level] !== null);
+}
+
+function buildThinkingPromptParts(model: unknown): { promptSnippet?: string; promptGuidelines?: string[] } {
+	const levels = getAvailableTodoThinkingLevels(model);
+	if (levels.length <= 1) return {};
+	return {
+		promptSnippet: `${DEFAULT_PROMPT_SNIPPET} Optional per-item thinking: ${levels.join("|")}.`.trim(),
+		promptGuidelines: [
+			...DEFAULT_PROMPT_GUIDELINES,
+			`If todoThinking is enabled, assign task \`thinking\` during create/batch_create or update whenever planned items differ in complexity; choose from ${levels.join(", ")}. Use higher thinking for investigation, hard debugging, risky edits, or review; use lower/off for mechanical steps and the final user-facing report. Do not leave all thinking unset for a non-trivial mixed-complexity plan.`,
+		],
+	};
+}
 
 function isAskUserToolName(toolName: string): boolean {
 	return ASK_USER_TOOL_NAMES.has(toolName);
@@ -45,7 +74,7 @@ function getUnfinishedTodoNudge(): { signature: string; message: string } | unde
 		message: [
 			"Todo auto-nudge: unfinished todo items remain after your last response.",
 			"Continue working on them now. Pick exactly one pending/in_progress item, mark it in_progress if needed, make concrete progress, and update or complete todos immediately as work changes.",
-			"If the user added/removed/canceled requirements or changed goal/scope/priority/approach, or if discovered facts make the current plan stale/incomplete/impossible, synchronize todos first: update still-relevant items, defer/delete obsolete ones, add new tasks, and adjust blockers/order.",
+			"If the user added/removed/canceled requirements or changed goal/scope/approach, or if discovered facts make the current plan stale/incomplete/impossible, synchronize todos first: update still-relevant items, defer/delete obsolete ones, add new tasks, and adjust blockers/order.",
 			"If progress is waiting on user-supplied data, clarification, or a decision, defer the affected plan/todos before your final response instead of leaving them pending/in_progress, so auto-nudge stops until the user replies.",
 			"For non-user blockers, leave the current item in_progress and create/update a blocker task instead of stopping.",
 			"",
@@ -59,9 +88,8 @@ function getPersistedPlanPrompt(path: string): string | undefined {
 	if (unfinished.length === 0) return undefined;
 	const lines = unfinished.slice(0, TODO_NUDGE_LIMIT).map((task) => {
 		const activeForm = task.activeForm ? ` — ${task.activeForm}` : "";
-		const priority = task.priority ? ` (${task.priority})` : "";
 		const blockedBy = task.blockedBy?.length ? ` (blocked by #${task.blockedBy.join(", #")})` : "";
-		return `- #${task.id} [${task.status}]${priority} ${task.subject}${activeForm}${blockedBy}`;
+		return `- #${task.id} [${task.status}] ${task.subject}${activeForm}${blockedBy}`;
 	});
 	if (unfinished.length > TODO_NUDGE_LIMIT) lines.push(`- …and ${unfinished.length - TODO_NUDGE_LIMIT} more unfinished todo item(s).`);
 	return [
@@ -84,9 +112,86 @@ function emitPersistedPlanPrompt(pi: ExtensionAPI, ctx: ExtensionContext, prompt
 }
 
 export default function (pi: ExtensionAPI) {
+	let currentModel: unknown;
+	const todoThinkingEnabled = loadPiToolsSuiteConfig(["todo"]).todoThinking;
+	const rememberedThinkingByTaskId = new Map<number, TodoThinkingLevel>();
 	let lastNudgedSignature: string | undefined;
 	let nudgeTimer: ReturnType<typeof setTimeout> | undefined;
 	const pendingAskUserToolCallIds = new Set<string>();
+	let suppressNextNudgeForThinkingSwitch = false;
+
+	function registerTodoToolWithCurrentPrompt(): void {
+		const thinkingPrompt = todoThinkingEnabled ? buildThinkingPromptParts(currentModel) : {};
+		registerTodoTool(pi, {
+			...thinkingPrompt,
+			afterCommit: async (state, ctx, info) => {
+				if (todoThinkingEnabled) applyTodoThinkingAfterCommit(state, info);
+				try {
+					const sync = syncPersistedPlan(ctx.cwd, state);
+					if (sync?.completed) console.log(`rpiv-todo: completed persisted plan and removed ${sync.path}`);
+				} catch (err) {
+					console.warn(`rpiv-todo: failed to sync persisted plan — ${(err as Error).message}`);
+				}
+			},
+		});
+	}
+
+	function applyTodoThinkingAfterCommit(state: ReturnType<typeof getState>, info: { action: string; params: TaskMutationParams }): void {
+		const mutations = getTodoThinkingMutations(info.action, info.params);
+		for (const mutation of mutations) {
+			if (mutation.id === undefined || mutation.status === "in_progress") continue;
+			restoreTaskThinking(mutation.id);
+		}
+		restoreInactiveTodoThinking(state);
+		for (const mutation of mutations) {
+			if (mutation.id === undefined) continue;
+			const task = state.tasks.find((item) => item.id === mutation.id);
+			if (!task || task.status !== "in_progress" || !task.thinking) continue;
+			if (mutation.status !== "in_progress" && mutation.thinking === undefined) continue;
+			switchToTaskThinking(task.id, task.thinking);
+		}
+	}
+
+	function getTodoThinkingMutations(action: string, params: TaskMutationParams): TaskMutationParams[] {
+		if (action === "update") return [params];
+		if (action === "batch_update") return params.items ?? [];
+		return [];
+	}
+
+	function getCurrentThinkingLevel(): TodoThinkingLevel | undefined {
+		const level = (pi as { getThinkingLevel?: () => unknown }).getThinkingLevel?.();
+		return isTodoThinkingLevel(level) ? level : undefined;
+	}
+
+	function switchToTaskThinking(taskId: number, level: TodoThinkingLevel): void {
+		if (!getAvailableTodoThinkingLevels(currentModel).includes(level)) return;
+		const current = getCurrentThinkingLevel();
+		if (!current) return;
+		if (!rememberedThinkingByTaskId.has(taskId)) rememberedThinkingByTaskId.set(taskId, current);
+		if (current !== level) setTodoThinkingLevel(level);
+	}
+
+	function restoreTaskThinking(taskId: number): void {
+		const previous = rememberedThinkingByTaskId.get(taskId);
+		if (!previous) return;
+		rememberedThinkingByTaskId.delete(taskId);
+		if (getCurrentThinkingLevel() !== previous) setTodoThinkingLevel(previous);
+	}
+
+	function restoreInactiveTodoThinking(state: ReturnType<typeof getState>): void {
+		for (const taskId of [...rememberedThinkingByTaskId.keys()]) {
+			const task = state.tasks.find((item) => item.id === taskId);
+			if (task?.status === "in_progress") continue;
+			restoreTaskThinking(taskId);
+		}
+	}
+
+	function setTodoThinkingLevel(level: TodoThinkingLevel): void {
+		const setter = (pi as { setThinkingLevel?: (level: TodoThinkingLevel) => void }).setThinkingLevel;
+		if (!setter) return;
+		suppressNextNudgeForThinkingSwitch = true;
+		setter.call(pi, level);
+	}
 
 	function clearNudgeTimer(): void {
 		if (!nudgeTimer) return;
@@ -127,19 +232,12 @@ export default function (pi: ExtensionAPI) {
 		}, delayMs);
 	}
 
-	registerTodoTool(pi, {
-		afterCommit: (state, ctx) => {
-			try {
-				const sync = syncPersistedPlan(ctx.cwd, state);
-				if (sync?.completed) console.log(`rpiv-todo: completed persisted plan and removed ${sync.path}`);
-			} catch (err) {
-				console.warn(`rpiv-todo: failed to sync persisted plan — ${(err as Error).message}`);
-			}
-		},
-	});
+	registerTodoToolWithCurrentPrompt();
 	registerTodosCommand(pi);
 
 	pi.on("session_start", async (_event, ctx) => {
+		currentModel = ctx.model;
+		registerTodoToolWithCurrentPrompt();
 		const persisted = loadPersistedPlan(ctx.cwd);
 		const loaded = autoClearCompletedTodos(persisted?.state ?? replayFromBranch(ctx));
 		replaceState(loaded.state);
@@ -171,6 +269,11 @@ export default function (pi: ExtensionAPI) {
 		clearNudgeTimer();
 	});
 
+	pi.on("model_select", async (event) => {
+		currentModel = event.model;
+		if (todoThinkingEnabled) registerTodoToolWithCurrentPrompt();
+	});
+
 	// Reads getTodos() at render time; do NOT call replayFromBranch here
 	// (branch is stale — message_end runs after tool_execution_end).
 	pi.on("tool_execution_start", async (event) => {
@@ -188,6 +291,12 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	pi.on("agent_end", async (_event, ctx) => {
+		if (suppressNextNudgeForThinkingSwitch) {
+			suppressNextNudgeForThinkingSwitch = false;
+			clearNudgeTimer();
+			return;
+		}
+
 		if (pendingAskUserToolCallIds.size > 0) {
 			clearNudgeTimer();
 			return;

package/external/pi-tools-suite/src/todo/state/persistence.ts

@@ -22,7 +22,6 @@ function cloneTask(task: Task): Task {
 	return {
 		...task,
 		blockedBy: task.blockedBy ? [...task.blockedBy] : undefined,
-		tags: task.tags ? [...task.tags] : undefined,
 		metadata: task.metadata ? { ...task.metadata } : undefined,
 	};
 }

package/external/pi-tools-suite/src/todo/state/state-reducer.ts

@@ -1,18 +1,18 @@
-import type { Task, TaskAction, TaskMutationParams, TaskPriority, TaskStatus } from "../tool/types.js";
+import type { Task, TaskAction, TaskMutationParams, TaskStatus, TodoThinkingLevel } from "../tool/types.js";
 import { isTransitionValid } from "./invariants.js";
 import type { TaskState } from "./state.js";
 import { detectCycle } from "./task-graph.js";
 
 export type Op =
-	| { kind: "create"; taskId: number }
+	| { kind: "create"; taskId: number; replacedCount?: number }
 	| { kind: "update"; id: number; fromStatus: TaskStatus; toStatus: TaskStatus }
-	| { kind: "batch_create"; ids: number[] }
+	| { kind: "batch_create"; ids: number[]; replacedCount?: number }
 	| { kind: "batch_update"; ids: number[] }
 	| { kind: "delete"; id: number; subject: string }
-	| { kind: "list"; statusFilter?: TaskStatus; priorityFilter?: TaskPriority; tagFilter?: string; blockedOnly: boolean; includeDeleted: boolean }
+	| { kind: "list"; statusFilter?: TaskStatus; blockedOnly: boolean; includeDeleted: boolean }
 	| { kind: "get"; task: Task }
 	| { kind: "clear"; count: number }
-	| { kind: "export"; format: "json" | "markdown"; statusFilter?: TaskStatus; priorityFilter?: TaskPriority; tagFilter?: string; blockedOnly: boolean; includeDeleted: boolean }
+	| { kind: "export"; format: "json" | "markdown"; statusFilter?: TaskStatus; blockedOnly: boolean; includeDeleted: boolean }
 	| { kind: "import"; count: number; replaced: boolean }
 	| { kind: "error"; message: string };
 
@@ -29,9 +29,8 @@ function uniqueNumbers(values: number[] | undefined): number[] {
 	return [...new Set((values ?? []).filter((value) => Number.isFinite(value)))];
 }
 
-function normalizeTags(tags: string[] | undefined): string[] | undefined {
-	const normalized = [...new Set((tags ?? []).map((tag) => tag.trim()).filter(Boolean))];
-	return normalized.length ? normalized : undefined;
+function isTodoThinkingLevel(value: unknown): value is TodoThinkingLevel {
+	return value === "off" || value === "minimal" || value === "low" || value === "medium" || value === "high" || value === "xhigh";
 }
 
 function findTask(state: TaskState, id: number): Task | undefined {
@@ -87,12 +86,10 @@ function coerceTask(value: unknown, fallbackId: number): Task | undefined {
 	const task: Task = { id: typeof v.id === "number" && Number.isFinite(v.id) ? v.id : fallbackId, subject, status };
 	if (typeof v.description === "string" && v.description) task.description = v.description;
 	if (typeof v.activeForm === "string" && v.activeForm) task.activeForm = v.activeForm;
-	if (v.priority === "low" || v.priority === "medium" || v.priority === "high" || v.priority === "urgent") task.priority = v.priority;
+	if (isTodoThinkingLevel(v.thinking)) task.thinking = v.thinking;
 	if (typeof v.parentId === "number" && Number.isFinite(v.parentId)) task.parentId = v.parentId;
 	const blockedBy = Array.isArray(v.blockedBy) ? uniqueNumbers(v.blockedBy as number[]) : undefined;
 	if (blockedBy?.length) task.blockedBy = blockedBy;
-	const tags = Array.isArray(v.tags) ? normalizeTags(v.tags.filter((tag): tag is string => typeof tag === "string")) : undefined;
-	if (tags) task.tags = tags;
 	if (typeof v.owner === "string" && v.owner) task.owner = v.owner;
 	if (v.metadata && typeof v.metadata === "object" && !Array.isArray(v.metadata)) task.metadata = { ...(v.metadata as Record<string, unknown>) };
 	return task;
@@ -114,12 +111,11 @@ function parseMarkdownImport(content: string): Task[] {
 	const tasks: Task[] = [];
 	const stack: Array<{ indent: number; id: number }> = [];
 	for (const line of content.split(/\r?\n/)) {
-		const match = /^(\s*)- \[([ xX])\](?: #(\d+))?(?: \((low|medium|high|urgent)\))? (.+?)(?: \[(#[^\]]+)\])?$/.exec(line);
+		const match = /^(\s*)- \[([ xX])\](?: #(\d+))? (.+?)$/.exec(line);
 		if (!match) continue;
 		const indent = match[1].length;
 		const id = match[3] ? Number(match[3]) : tasks.length + 1;
-		const tags = match[6] ? normalizeTags(match[6].split(/\s+/).map((tag) => tag.replace(/^#/, ""))) : undefined;
-		const subjectParts = match[5].split(/\s+⛓\s+/);
+		const subjectParts = match[4].split(/\s+⛓\s+/);
 		const blockedBy = subjectParts[1] ? uniqueNumbers(subjectParts[1].split(/\s*,\s*/).map((ref) => Number(ref.replace(/^#/, "")))) : [];
 		while (stack.length && stack[stack.length - 1].indent >= indent) stack.pop();
 		const rawSubject = subjectParts[0];
@@ -132,10 +128,8 @@ function parseMarkdownImport(content: string): Task[] {
 			subject: rawSubject.replace(/\s+\{deferred\}$/, "").trim(),
 			status,
 		};
-		if (match[4]) task.priority = match[4] as TaskPriority;
 		if (stack.length) task.parentId = stack[stack.length - 1].id;
 		if (blockedBy.length) task.blockedBy = blockedBy;
-		if (tags) task.tags = tags;
 		tasks.push(task);
 		stack.push({ indent, id });
 	}
@@ -147,7 +141,6 @@ function remapImportedTasks(imported: readonly Task[], state: TaskState, replace
 		return imported.map((task) => ({
 			...task,
 			blockedBy: task.blockedBy ? [...task.blockedBy] : undefined,
-			tags: task.tags ? [...task.tags] : undefined,
 		}));
 	}
 	const idMap = new Map<number, number>();
@@ -157,7 +150,6 @@ function remapImportedTasks(imported: readonly Task[], state: TaskState, replace
 		id: idMap.get(task.id) ?? task.id,
 		parentId: task.parentId !== undefined ? (idMap.get(task.parentId) ?? task.parentId) : undefined,
 		blockedBy: task.blockedBy?.map((id) => idMap.get(id) ?? id),
-		tags: task.tags ? [...task.tags] : undefined,
 	}));
 }
 
@@ -165,26 +157,29 @@ export function applyTaskMutation(state: TaskState, action: TaskAction, params:
 	switch (action) {
 		case "create": {
 			if (!params.subject?.trim()) return errorResult(state, "subject required for create");
+			const replacedCount = params.replace === true ? state.tasks.length : 0;
+			const baseState = params.replace === true ? { tasks: [], nextId: 1 } : state;
 			if (params.parentId !== undefined && params.parentId !== null) {
-				const err = validateLiveReference(state, "parentId", params.parentId);
+				const err = validateLiveReference(baseState, "parentId", params.parentId);
 				if (err) return errorResult(state, err);
 			}
 			for (const dep of uniqueNumbers(params.blockedBy)) {
-				const err = validateLiveReference(state, "blockedBy", dep);
+				const err = validateLiveReference(baseState, "blockedBy", dep);
 				if (err) return errorResult(state, err);
 			}
-			const newTask: Task = { id: state.nextId, subject: params.subject.trim(), status: "pending" };
+			const newTask: Task = { id: baseState.nextId, subject: params.subject.trim(), status: "pending" };
 			if (params.description) newTask.description = params.description;
 			if (params.activeForm) newTask.activeForm = params.activeForm;
-			if (params.priority) newTask.priority = params.priority;
+			if (params.thinking) newTask.thinking = params.thinking;
 			if (params.parentId !== undefined && params.parentId !== null) newTask.parentId = params.parentId;
 			const blockedBy = uniqueNumbers(params.blockedBy);
 			if (blockedBy.length) newTask.blockedBy = blockedBy;
-			const tags = normalizeTags(params.tags);
-			if (tags) newTask.tags = tags;
 			if (params.owner) newTask.owner = params.owner;
 			if (params.metadata) newTask.metadata = { ...params.metadata };
-			return { state: { tasks: [...state.tasks, newTask], nextId: state.nextId + 1 }, op: { kind: "create", taskId: newTask.id } };
+			return {
+				state: { tasks: [...baseState.tasks, newTask], nextId: baseState.nextId + 1 },
+				op: { kind: "create", taskId: newTask.id, ...(replacedCount > 0 ? { replacedCount } : {}) },
+			};
 		}
 
 		case "update": {
@@ -194,8 +189,8 @@ export function applyTaskMutation(state: TaskState, action: TaskAction, params:
 			const current = state.tasks[idx];
 			const hasMutation =
 				params.subject !== undefined || params.description !== undefined || params.activeForm !== undefined || params.status !== undefined ||
-				params.priority !== undefined || params.parentId !== undefined || params.clearParent === true || params.owner !== undefined ||
-				params.metadata !== undefined || params.tags !== undefined || (params.addTags?.length ?? 0) > 0 || (params.removeTags?.length ?? 0) > 0 ||
+				params.thinking !== undefined || params.parentId !== undefined || params.clearParent === true || params.owner !== undefined ||
+				params.metadata !== undefined ||
 				(params.addBlockedBy?.length ?? 0) > 0 || (params.removeBlockedBy?.length ?? 0) > 0;
 			if (!hasMutation) return errorResult(state, "update requires at least one mutable field");
 
@@ -230,13 +225,6 @@ export function applyTaskMutation(state: TaskState, action: TaskAction, params:
 				if (detectCycle(state.tasks, current.id, newBlockedBy)) return errorResult(state, "addBlockedBy would create a cycle in the blockedBy graph");
 			}
 
-			let newTags = params.tags !== undefined ? normalizeTags(params.tags) : current.tags ? [...current.tags] : undefined;
-			if (params.addTags?.length) newTags = normalizeTags([...(newTags ?? []), ...params.addTags]);
-			if (params.removeTags?.length && newTags) {
-				const remove = new Set(params.removeTags.map((tag) => tag.trim()).filter(Boolean));
-				newTags = normalizeTags(newTags.filter((tag) => !remove.has(tag)));
-			}
-
 			let newMetadata = current.metadata;
 			if (params.metadata !== undefined) {
 				const merged: Record<string, unknown> = { ...(current.metadata ?? {}) };
@@ -248,14 +236,12 @@ export function applyTaskMutation(state: TaskState, action: TaskAction, params:
 			if (params.subject !== undefined) updated.subject = params.subject;
 			if (params.description !== undefined) updated.description = params.description;
 			if (params.activeForm !== undefined) updated.activeForm = params.activeForm;
-			if (params.priority !== undefined) updated.priority = params.priority;
+			if (params.thinking !== undefined) updated.thinking = params.thinking;
 			if (params.owner !== undefined) updated.owner = params.owner;
 			if (newParentId === undefined) delete updated.parentId;
 			else updated.parentId = newParentId;
 			if (newBlockedBy.length) updated.blockedBy = newBlockedBy;
 			else delete updated.blockedBy;
-			if (newTags) updated.tags = newTags;
-			else delete updated.tags;
 			if (newMetadata === undefined) delete updated.metadata;
 			else updated.metadata = newMetadata;
 
@@ -266,7 +252,8 @@ export function applyTaskMutation(state: TaskState, action: TaskAction, params:
 
 		case "batch_create": {
 			if (!params.items?.length) return errorResult(state, "items required for batch_create");
-			let working = state;
+			const replacedCount = params.replace === true ? state.tasks.length : 0;
+			let working = params.replace === true ? { tasks: [], nextId: 1 } : state;
 			const ids: number[] = [];
 			for (let i = 0; i < params.items.length; i++) {
 				const result = applyTaskMutation(working, "create", { ...params.items[i], action: "create" });
@@ -274,7 +261,7 @@ export function applyTaskMutation(state: TaskState, action: TaskAction, params:
 				if (result.op.kind === "create") ids.push(result.op.taskId);
 				working = result.state;
 			}
-			return { state: working, op: { kind: "batch_create", ids } };
+			return { state: working, op: { kind: "batch_create", ids, ...(replacedCount > 0 ? { replacedCount } : {}) } };
 		}
 
 		case "batch_update": {
@@ -298,8 +285,6 @@ export function applyTaskMutation(state: TaskState, action: TaskAction, params:
 					includeDeleted: params.includeDeleted === true,
 					blockedOnly: params.blockedOnly === true,
 					...(params.status ? { statusFilter: params.status } : {}),
-					...(params.priority ? { priorityFilter: params.priority } : {}),
-					...(params.tag ? { tagFilter: params.tag } : {}),
 				},
 			};
 
@@ -337,8 +322,6 @@ export function applyTaskMutation(state: TaskState, action: TaskAction, params:
 					includeDeleted: params.includeDeleted === true,
 					blockedOnly: params.blockedOnly === true,
 					...(params.status ? { statusFilter: params.status } : {}),
-					...(params.priority ? { priorityFilter: params.priority } : {}),
-					...(params.tag ? { tagFilter: params.tag } : {}),
 				},
 			};
 

package/external/pi-tools-suite/src/todo/todo.ts

@@ -34,7 +34,6 @@ import {
 	type Task,
 	type TaskAction,
 	type TaskMutationParams,
-	type TaskPriority,
 	type TaskStatus,
 	TOOL_LABEL,
 	TOOL_NAME,
@@ -63,8 +62,6 @@ const TODOS_ARGUMENT_COMPLETIONS: CommandCompletion[] = [
 	{ value: "--ready", label: "--ready", description: "Show pending tasks whose blockers are completed" },
 	{ value: "--blocked", label: "--blocked", description: "Show tasks with blockers" },
 	{ value: "--tree", label: "--tree", description: "Show parent/subtask tree" },
-	{ value: "--tag ", label: "--tag <tag>", description: "Filter by tag" },
-	{ value: "--priority ", label: "--priority <level>", description: "Filter by priority" },
 	{ value: "--status ", label: "--status <status>", description: "Filter by status" },
 	{ value: "--export markdown", label: "--export markdown", description: "Export visible todos as Markdown" },
 	{ value: "--export json", label: "--export json", description: "Export visible todos as JSON" },
@@ -78,7 +75,12 @@ const PERSIST_ARGUMENT_COMPLETIONS: CommandCompletion[] = [
 ];
 
 interface TodoToolHooks {
-	afterCommit?: (state: ReturnType<typeof getState>, ctx: ExtensionContext) => void | Promise<void>;
+	afterCommit?: (state: ReturnType<typeof getState>, ctx: ExtensionContext, info: { action: TaskAction; params: TaskMutationParams }) => void | Promise<void>;
+}
+
+interface TodoToolRegistrationOptions extends TodoToolHooks {
+	promptSnippet?: string;
+	promptGuidelines?: string[];
 }
 
 type TodoStateEventContext = { sessionManager?: { getSessionFile?: () => unknown } };
@@ -86,8 +88,6 @@ type TodoStateEventEmitter = { events?: { emit?: (channel: string, data: unknown
 
 interface TodosCommandOptions {
 	status?: TaskStatus;
-	priority?: TaskPriority;
-	tag?: string;
 	blockedOnly: boolean;
 	readyOnly: boolean;
 	activeOnly: boolean;
@@ -125,12 +125,6 @@ function parseTodosArgs(args: unknown): TodosCommandOptions {
 			case "--include-deleted":
 				options.includeDeleted = true;
 				break;
-			case "--tag":
-				if (next) options.tag = tokens[++i].replace(/^#/, "");
-				break;
-			case "--priority":
-				if (next === "low" || next === "medium" || next === "high" || next === "urgent") options.priority = tokens[++i] as TaskPriority;
-				break;
 			case "--status":
 				if (next === "pending" || next === "in_progress" || next === "deferred" || next === "completed" || next === "deleted") options.status = tokens[++i] as TaskStatus;
 				break;
@@ -290,9 +284,6 @@ function filterCommandTasks(tasks: readonly Task[], options: TodosCommandOptions
 		view = view.filter((task) => task.status === "pending" && !isTaskBlocked(task, byId));
 	}
 	if (options.status) view = view.filter((task) => task.status === options.status);
-	if (options.priority) view = view.filter((task) => task.priority === options.priority);
-	const tag = options.tag;
-	if (tag) view = view.filter((task) => task.tags?.includes(tag));
 	if (options.blockedOnly) view = view.filter((task) => (task.blockedBy?.length ?? 0) > 0);
 	return view;
 }
@@ -343,7 +334,7 @@ export { isTransitionValid } from "./state/invariants.js";
 export { applyTaskMutation } from "./state/state-reducer.js";
 export { __resetState, getNextId, getTodos } from "./state/store.js";
 export { deriveBlocks, detectCycle } from "./state/task-graph.js";
-export type { Task, TaskAction, TaskDetails, TaskPriority, TaskStatus } from "./tool/types.js";
+export type { Task, TaskAction, TaskDetails, TaskStatus } from "./tool/types.js";
 export { TOOL_NAME } from "./tool/types.js";
 
 /**
@@ -362,13 +353,13 @@ export function reconstructTodoState(ctx: Parameters<typeof replayFromBranch>[0]
 export const DEFAULT_PROMPT_SNIPPET = TODO_TOOL_DESCRIPTION.promptSnippet ?? "";
 export const DEFAULT_PROMPT_GUIDELINES: string[] = TODO_TOOL_DESCRIPTION.promptGuidelines ?? [];
 
-export function registerTodoTool(pi: ExtensionAPI, hooks: TodoToolHooks = {}): void {
+export function registerTodoTool(pi: ExtensionAPI, hooks: TodoToolRegistrationOptions = {}): void {
 	pi.registerTool({
 		...TODO_TOOL_DESCRIPTION,
 		name: TOOL_NAME,
 		label: TOOL_LABEL,
-		promptSnippet: DEFAULT_PROMPT_SNIPPET,
-		promptGuidelines: DEFAULT_PROMPT_GUIDELINES,
+		promptSnippet: hooks.promptSnippet ?? DEFAULT_PROMPT_SNIPPET,
+		promptGuidelines: hooks.promptGuidelines ?? DEFAULT_PROMPT_GUIDELINES,
 		parameters: TodoParamsSchema,
 
 		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
@@ -379,7 +370,7 @@ export function registerTodoTool(pi: ExtensionAPI, hooks: TodoToolHooks = {}): v
 			const autoClear = autoClearCompletedTodos(result.state);
 			commitState(autoClear.state);
 			publishTodoState(pi as TodoStateEventEmitter, _ctx, params.action, params as Record<string, unknown>);
-			await hooks.afterCommit?.(autoClear.state, _ctx as ExtensionContext);
+			await hooks.afterCommit?.(autoClear.state, _ctx as ExtensionContext, { action: params.action, params: params as TaskMutationParams });
 			const toolResult = buildToolResult(params.action, params as TaskMutationParams, autoClear.state, result.op);
 			if (!autoClear.cleared) return toolResult;
 			return {
@@ -397,7 +388,7 @@ export function registerTodoTool(pi: ExtensionAPI, hooks: TodoToolHooks = {}): v
 
 export function registerTodosCommand(pi: ExtensionAPI): void {
 	pi.registerCommand(COMMAND_NAME, {
-		description: "Show todos on the current branch. Flags: --active, --ready, --blocked, --tree, --tag <tag>, --priority <level>, --status <status>, --export [json|markdown]. Commands: persist on|off|clear|status, scope <id...>",
+	description: "Show todos on the current branch. Flags: --active, --ready, --blocked, --tree, --status <status>, --export [json|markdown]. Commands: persist on|off|clear|status, scope <id...>",
 		getArgumentCompletions: (prefix) => completeCommandArguments(String(prefix ?? ""), TODOS_ARGUMENT_COMPLETIONS),
 		handler: async (args, ctx) => {
 			if (handlePersistCommand(args, ctx)) return;
@@ -416,8 +407,6 @@ export function registerTodosCommand(pi: ExtensionAPI): void {
 					includeDeleted: options.includeDeleted,
 					blockedOnly: options.blockedOnly,
 					...(options.status ? { statusFilter: options.status } : {}),
-					...(options.priority ? { priorityFilter: options.priority } : {}),
-					...(options.tag ? { tagFilter: options.tag } : {}),
 				};
 				ctx.ui.notify(formatContent(op, exportState), "info");
 				return;

package/external/pi-tools-suite/src/todo/tool/response-envelope.ts

@@ -10,10 +10,9 @@ import type { Task, TaskAction, TaskDetails, TaskMutationParams } from "./types.
 function formatListLine(t: Task): string {
 	const block = t.blockedBy?.length ? ` ⛓ ${t.blockedBy.map((id) => `#${id}`).join(",")}` : "";
 	const parent = t.parentId !== undefined ? ` ↳ #${t.parentId}` : "";
-	const priority = t.priority ? ` (${t.priority})` : "";
-	const tags = t.tags?.length ? ` ${t.tags.map((tag) => `#${tag}`).join(" ")}` : "";
+	const thinking = t.thinking ? ` {thinking:${t.thinking}}` : "";
 	const form = t.status === "in_progress" && t.activeForm ? ` (${t.activeForm})` : "";
-	return `[${t.status}] #${t.id} ${t.subject}${priority}${form}${parent}${block}${tags}`;
+	return `[${t.status}] #${t.id} ${t.subject}${thinking}${form}${parent}${block}`;
 }
 
 /**
@@ -25,7 +24,7 @@ function formatGetLines(task: Task, state: TaskState): string {
 	const lines = [`#${task.id} [${task.status}] ${task.subject}`];
 	if (task.description) lines.push(`  description: ${task.description}`);
 	if (task.activeForm) lines.push(`  activeForm: ${task.activeForm}`);
-	if (task.priority) lines.push(`  priority: ${task.priority}`);
+	if (task.thinking) lines.push(`  thinking: ${task.thinking}`);
 	if (task.parentId !== undefined) lines.push(`  parentId: #${task.parentId}`);
 	if (task.blockedBy?.length) {
 		lines.push(`  blockedBy: ${task.blockedBy.map((id) => `#${id}`).join(", ")}`);
@@ -33,7 +32,6 @@ function formatGetLines(task: Task, state: TaskState): string {
 	if (blocks.length) {
 		lines.push(`  blocks: ${blocks.map((id) => `#${id}`).join(", ")}`);
 	}
-	if (task.tags?.length) lines.push(`  tags: ${task.tags.map((tag) => `#${tag}`).join(" ")}`);
 	if (task.owner) lines.push(`  owner: ${task.owner}`);
 	return lines.join("\n");
 }
@@ -42,13 +40,15 @@ function filterTasks(op: Extract<Op, { kind: "list" | "export" }>, state: TaskSt
 	let view = state.tasks;
 	if (!op.includeDeleted) view = view.filter((t) => t.status !== "deleted");
 	if (op.statusFilter) view = view.filter((t) => t.status === op.statusFilter);
-	if (op.priorityFilter) view = view.filter((t) => t.priority === op.priorityFilter);
-	const tagFilter = op.tagFilter;
-	if (tagFilter) view = view.filter((t) => t.tags?.includes(tagFilter));
 	if (op.blockedOnly) view = view.filter((t) => (t.blockedBy?.length ?? 0) > 0);
 	return view;
 }
 
+function formatReplacePrefix(replacedCount: number | undefined): string {
+	if (!replacedCount) return "";
+	return `Replaced ${replacedCount} existing todo item${replacedCount === 1 ? "" : "s"}; `;
+}
+
 function formatMarkdownExport(tasks: readonly Task[]): string {
 	const byParent = new Map<number | undefined, Task[]>();
 	for (const task of tasks) {
@@ -62,11 +62,9 @@ function formatMarkdownExport(tasks: readonly Task[]): string {
 		if (seen.has(task.id)) return;
 		seen.add(task.id);
 		const checked = task.status === "completed" ? "x" : " ";
-		const priority = task.priority ? ` (${task.priority})` : "";
 		const status = task.status === "deferred" ? " {deferred}" : "";
-		const tags = task.tags?.length ? ` [${task.tags.map((tag) => `#${tag}`).join(" ")}]` : "";
 		const blocked = task.blockedBy?.length ? ` ⛓ ${task.blockedBy.map((id) => `#${id}`).join(",")}` : "";
-		lines.push(`${"  ".repeat(depth)}- [${checked}] #${task.id}${priority} ${task.subject}${status}${blocked}${tags}`);
+		lines.push(`${"  ".repeat(depth)}- [${checked}] #${task.id} ${task.subject}${status}${blocked}`);
 		for (const child of byParent.get(task.id) ?? []) visit(child, depth + 1);
 	};
 	for (const root of byParent.get(undefined) ?? []) visit(root, 0);
@@ -85,15 +83,15 @@ export function formatContent(op: Op, state: TaskState): string {
 		case "create": {
 			const t = state.tasks.find((x) => x.id === op.taskId);
 			// Defensive — `op.taskId` always resolves on success path.
-			if (!t) return `Created #${op.taskId}`;
-			return `Created #${t.id}: ${t.subject} (pending)`;
+			if (!t) return `${formatReplacePrefix(op.replacedCount)}Created #${op.taskId}`;
+			return `${formatReplacePrefix(op.replacedCount)}Created #${t.id}: ${t.subject} (pending)`;
 		}
 		case "update": {
 			const transition = op.fromStatus !== op.toStatus ? ` (${op.fromStatus} → ${op.toStatus})` : "";
 			return `Updated #${op.id}${transition}`;
 		}
 		case "batch_create":
-			return `Created ${op.ids.length} tasks: ${op.ids.map((id) => `#${id}`).join(", ")}`;
+			return `${formatReplacePrefix(op.replacedCount)}Created ${op.ids.length} tasks: ${op.ids.map((id) => `#${id}`).join(", ")}`;
 		case "batch_update":
 			return `Updated ${op.ids.length} tasks: ${op.ids.map((id) => `#${id}`).join(", ")}`;
 		case "delete":
@@ -144,8 +142,28 @@ export function buildToolResult(
 
 function appendWorkflowReminder(text: string, op: Op, state: TaskState): string {
 	if (op.kind === "error" || op.kind === "export") return text;
+	const lines = [text];
+	if (op.kind === "create" || op.kind === "batch_create") {
+		lines.push(
+			"Reminder: if this is a multi-step task, include a final todo item for the user-facing final report before completion. Give that final-report todo an explicit description/acceptance criteria: summarize changed files and behavior, list verification commands/results, mention any remaining manual action, and never replace the user-facing report with a compression/housekeeping note.",
+		);
+		const createdIds = new Set(op.kind === "create" ? [op.taskId] : op.ids);
+		const hasOlderUnfinished = !op.replacedCount && state.tasks.some((task) => {
+			if (createdIds.has(task.id)) return false;
+			return task.status !== "completed" && task.status !== "deleted";
+		});
+		if (hasOlderUnfinished) {
+			lines.push(
+				"Reminder: existing unfinished todos are still present. If this is a new plan that supersedes them, use batch_create with replace:true or explicitly update/defer/delete obsolete tasks.",
+			);
+		}
+	}
 	const hasPending = state.tasks.some((task) => task.status === "pending");
 	const hasInProgress = state.tasks.some((task) => task.status === "in_progress");
-	if (!hasPending || hasInProgress) return text;
-	return `${text}\n\nReminder: pending todos exist but none is in_progress. Before starting work, call todo update on exactly one task with status in_progress and activeForm.`;
+	if (hasPending && !hasInProgress) {
+		lines.push(
+			"Reminder: pending todos exist but none is in_progress. Before starting work, call todo update on exactly one task with status in_progress and activeForm.",
+		);
+	}
+	return lines.join("\n\n");
 }