pi-ui-extend 0.1.13 → 0.1.15

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

@@ -1,16 +1,46 @@
 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_RECONCILE_ACTIONS = new Set(["list"]);
+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, set task \`thinking\` only when useful; choose from ${levels.join(", ")}. Split todos to change thinking by work type (e.g. final report can use off; retry/hard debugging can use higher thinking).`,
+		],
+	};
+}
 
 function isAskUserToolName(toolName: string): boolean {
 	return ASK_USER_TOOL_NAMES.has(toolName);
@@ -54,6 +84,39 @@ function getUnfinishedTodoNudge(): { signature: string; message: string } | unde
 	};
 }
 
+function getTodoFinalGuardPrompt(): { signature: string; message: string } | undefined {
+	const nudge = getUnfinishedTodoNudge();
+	if (!nudge) return undefined;
+	return {
+		signature: nudge.signature,
+		message: nudge.message.replace(
+			"Todo auto-nudge: unfinished todo items remain after your last response.",
+			"Todo final reconciliation required before answering the user.",
+		).replace(
+			"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.",
+			"Run `todo list` first, reconcile the visible plan, then answer only after completed work is not left pending/in_progress/deferred by accident.",
+		),
+	};
+}
+
+function isFinalAssistantMessage(message: unknown): boolean {
+	if (!message || typeof message !== "object") return false;
+	const record = message as Record<string, unknown>;
+	if (record.role !== "assistant" || record.stopReason !== "stop") return false;
+	const content = record.content;
+	if (typeof content === "string") return content.trim().length > 0;
+	if (!Array.isArray(content)) return false;
+
+	let hasText = false;
+	for (const block of content) {
+		if (!block || typeof block !== "object") continue;
+		const part = block as Record<string, unknown>;
+		if (part.type === "toolCall" || part.type === "tool-call") return false;
+		if (typeof part.text === "string" && part.text.trim().length > 0) hasText = true;
+	}
+	return hasText;
+}
+
 function getPersistedPlanPrompt(path: string): string | undefined {
 	const unfinished = selectVisibleTasks(getState()).filter((task) => task.status !== "completed");
 	if (unfinished.length === 0) return undefined;
@@ -84,9 +147,95 @@ 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 lastFinalGuardSignature: string | undefined;
+	let todoDirtySinceReconcile = false;
 	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);
+
+				if (TODO_RECONCILE_ACTIONS.has(info.action)) {
+					todoDirtySinceReconcile = false;
+					lastFinalGuardSignature = undefined;
+				} else if (info.action !== "get" && info.action !== "export") {
+					todoDirtySinceReconcile = true;
+				}
+				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 +276,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 +313,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) => {
@@ -185,9 +332,32 @@ export default function (pi: ExtensionAPI) {
 
 	pi.on("agent_start", async () => {
 		pendingAskUserToolCallIds.clear();
+		todoDirtySinceReconcile = false;
+		lastFinalGuardSignature = undefined;
+	});
+
+	pi.on("message_end", async (event) => {
+		if (!todoDirtySinceReconcile) return;
+		if (pendingAskUserToolCallIds.size > 0) return;
+		if (!isFinalAssistantMessage(event.message)) return;
+
+		const guard = getTodoFinalGuardPrompt();
+		if (!guard) return;
+		if (guard.signature === lastFinalGuardSignature) return;
+
+		lastFinalGuardSignature = guard.signature;
+		lastNudgedSignature = guard.signature;
+		clearNudgeTimer();
+		pi.sendUserMessage(guard.message, { deliverAs: "followUp" });
 	});
 
 	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/state-reducer.ts

@@ -1,12 +1,12 @@
-import type { Task, TaskAction, TaskMutationParams, TaskPriority, TaskStatus } from "../tool/types.js";
+import type { Task, TaskAction, TaskMutationParams, TaskPriority, 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 }
@@ -34,6 +34,10 @@ function normalizeTags(tags: string[] | undefined): string[] | undefined {
 	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 {
 	return state.tasks.find((task) => task.id === id);
 }
@@ -88,6 +92,7 @@ function coerceTask(value: unknown, fallbackId: number): Task | undefined {
 	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;
@@ -165,18 +170,21 @@ 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;
@@ -184,7 +192,10 @@ export function applyTaskMutation(state: TaskState, action: TaskAction, params:
 			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,7 +205,7 @@ 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.priority !== undefined || params.thinking !== 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.addBlockedBy?.length ?? 0) > 0 || (params.removeBlockedBy?.length ?? 0) > 0;
 			if (!hasMutation) return errorResult(state, "update requires at least one mutable field");
@@ -249,6 +260,7 @@ export function applyTaskMutation(state: TaskState, action: TaskAction, params:
 			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;
@@ -266,7 +278,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 +287,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": {

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

@@ -78,7 +78,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 } };
@@ -362,13 +367,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 +384,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 {

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

@@ -11,9 +11,10 @@ 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 thinking = t.thinking ? ` {thinking:${t.thinking}}` : "";
 	const tags = t.tags?.length ? ` ${t.tags.map((tag) => `#${tag}`).join(" ")}` : "";
 	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}${priority}${thinking}${form}${parent}${block}${tags}`;
 }
 
 /**
@@ -26,6 +27,7 @@ function formatGetLines(task: Task, state: TaskState): string {
 	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(", ")}`);
@@ -49,6 +51,11 @@ function filterTasks(op: Extract<Op, { kind: "list" | "export" }>, state: TaskSt
 	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) {
@@ -85,15 +92,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 +151,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");
 }

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

@@ -25,6 +25,7 @@ export const MSG_NO_TODOS = "No todos yet. Ask the agent to add some!";
 
 export type TaskStatus = "pending" | "in_progress" | "deferred" | "completed" | "deleted";
 export type TaskPriority = "low" | "medium" | "high" | "urgent";
+export type TodoThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
 
 export type TaskAction = "create" | "update" | "batch_create" | "batch_update" | "list" | "get" | "delete" | "clear" | "export" | "import";
 
@@ -35,6 +36,7 @@ export interface Task {
 	activeForm?: string;
 	status: TaskStatus;
 	priority?: TaskPriority;
+	thinking?: TodoThinkingLevel;
 	parentId?: number;
 	blockedBy?: number[];
 	tags?: string[];
@@ -68,6 +70,7 @@ export interface TaskMutationParams {
 	activeForm?: string;
 	status?: TaskStatus;
 	priority?: TaskPriority;
+	thinking?: TodoThinkingLevel;
 	parentId?: number | null;
 	clearParent?: boolean;
 	blockedBy?: number[];
@@ -113,6 +116,11 @@ export const TodoParamsSchema = Type.Object({
 			description: "Task priority (create/update) or list/export filter (list/export)",
 		}),
 	),
+	thinking: Type.Optional(
+		StringEnum(["off", "minimal", "low", "medium", "high", "xhigh"] as const, {
+			description: "Per-task thinking level used when todoThinking is enabled and this task is in_progress",
+		}),
+	),
 	parentId: Type.Optional(
 		Type.Number({
 			description: "Parent task id for hierarchy/subtasks (create/update); must refer to a non-deleted task",
@@ -182,7 +190,7 @@ export const TodoParamsSchema = Type.Object({
 		}),
 	),
 	content: Type.Optional(Type.String({ description: "Import content for action=import" })),
-	replace: Type.Optional(Type.Boolean({ description: "For import, replace existing tasks instead of appending. Default: false." })),
+	replace: Type.Optional(Type.Boolean({ description: "For import/create/batch_create, replace existing tasks instead of appending. Use batch_create with replace:true when starting a new plan that supersedes old unfinished todos. Default: false." })),
 });
 
 export type TodoParams = Static<typeof TodoParamsSchema>;

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

@@ -11,8 +11,9 @@ export { formatStatusLabel };
 export function formatCommandTaskLine(t: Task, glyph: string): string {
 	const form = t.status === "in_progress" && t.activeForm ? ` (${t.activeForm})` : "";
 	const priority = t.priority ? ` (${t.priority})` : "";
+	const thinking = t.thinking ? ` {thinking:${t.thinking}}` : "";
 	const parent = t.parentId !== undefined ? `    ↳ #${t.parentId}` : "";
 	const block = t.blockedBy?.length ? `    ⛓ ${t.blockedBy.map((id) => `#${id}`).join(",")}` : "";
 	const tags = t.tags?.length ? `    ${t.tags.map((tag) => `#${tag}`).join(" ")}` : "";
-	return `  ${glyph} #${t.id} ${t.subject}${priority}${form}${parent}${block}${tags}`;
+	return `  ${glyph} #${t.id} ${t.subject}${priority}${thinking}${form}${parent}${block}${tags}`;
 }

package/external/pi-tools-suite/src/tool-descriptions.ts

@@ -249,7 +249,7 @@ export const REPO_DISCOVERY_TOOL_NAMES = REPO_DISCOVERY_TOOLS.map((tool) => tool
 export const TODO_TOOL_DESCRIPTION: ToolDescription = {
 	name: "todo",
 	label: "Todo",
-	description: "Track and keep in sync non-trivial multi-step work as todos. Actions: create, update, batch_create, batch_update, list, get, delete, clear, export, import. Supports priorities, tags, parent/subtask hierarchy, blockers, deferred out-of-scope items, and dependencies; skip trivial or chat-only requests. Resynchronize the plan when requirements are added, canceled, or become obsolete, whether from user input or discovered facts. Keep exactly one task in_progress and complete it only after verification.",
+	description: "Track and keep in sync non-trivial multi-step work as todos. Actions: create, update, batch_create, batch_update, list, get, delete, clear, export, import. Supports priorities, tags, parent/subtask hierarchy, blockers, deferred out-of-scope items, dependencies, and replace:true on create/batch_create/import for intentionally replacing an obsolete plan; skip trivial or chat-only requests. Resynchronize the plan when requirements are added, canceled, or become obsolete, whether from user input or discovered facts. Keep exactly one task in_progress and complete it only after verification.",
 	promptSnippet: "Track/sync non-trivial multi-step work; resync when requirements or discoveries change the plan; keep one task in_progress",
 	promptGuidelines: [
 		"Use `todo` for complex work with 3+ steps, explicit user task lists, or new non-trivial requirements. Skip single trivial tasks and purely conversational requests.",
@@ -262,6 +262,7 @@ export const TODO_TOOL_DESCRIPTION: ToolDescription = {
 		"Before giving a final response for work that used todos, ensure every visible todo is completed, deferred, or intentionally still in_progress with a blocker/explanation.",
 		"Keep subjects short and imperative; put details in description only when needed. Use priority, tags, and parentId for large plans; use blockedBy on create and addBlockedBy/removeBlockedBy on update for dependencies.",
 		"Use batch_create/batch_update for large explicit plans, but still keep exactly one visible task in_progress unless the user asks otherwise.",
+		"When starting a new plan that supersedes existing unfinished todos, use batch_create with replace:true instead of appending; only omit replace when intentionally extending the current plan.",
 		"list hides deleted tombstones unless includeDeleted:true; pass status, priority, tag, or blockedOnly only when you need a filtered list.",
 		"Use export/import for handoff or plan migration; import with replace:true only when the user explicitly wants to overwrite the current todo state.",
 		"When every visible todo is completed, todo state clears automatically; do not call clear afterward just to remove completed tasks.",

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

@@ -1,4 +1,4 @@
-import { getAgentDir, type ExtensionAPI, type ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
@@ -37,7 +37,10 @@ async function readOpenCodeAuth(): Promise<{ authData: AuthData; error?: string
 
 async function readPiAuth(): Promise<PiAuthData> {
 	try {
-		const content = await readFile(join(getAgentDir(), "auth.json"), "utf-8");
+		const authPath = process.env.NODE_ENV === "test" && process.env.PI_TOOLS_SUITE_TEST_AUTH_PATH
+			? process.env.PI_TOOLS_SUITE_TEST_AUTH_PATH
+			: join(homedir(), ".pi", "agent", "auth.json");
+		const content = await readFile(authPath, "utf-8");
 		return JSON.parse(content) as PiAuthData;
 	} catch {
 		return {};

package/external/pi-tools-suite/src/usage/lib/google.ts

@@ -7,7 +7,6 @@
  * [同步]: usage.ts, types.ts, utils.ts
  */
 
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
@@ -97,7 +96,9 @@ function getAntigravityAccountsPath(): string {
 }
 
 function getPiAuthPath(): string {
-  return join(getAgentDir(), "auth.json");
+  return process.env.NODE_ENV === "test" && process.env.PI_TOOLS_SUITE_TEST_AUTH_PATH
+    ? process.env.PI_TOOLS_SUITE_TEST_AUTH_PATH
+    : join(homedir(), ".pi", "agent", "auth.json");
 }
 
 function splitPiRefresh(refresh: string): AntigravityAccount | null {
@@ -156,14 +157,8 @@ async function readAntigravityAccounts(): Promise<AntigravityAccount[]> {
 
 const GOOGLE_TOKEN_REFRESH_URL = "https://oauth2.googleapis.com/token";
 
-const GOOGLE_CLIENT_ID =
-  process.env.PIX_ANTIGRAVITY_GOOGLE_CLIENT_ID ??
-  process.env.ANTIGRAVITY_GOOGLE_CLIENT_ID ??
-  "";
-const GOOGLE_CLIENT_SECRET =
-  process.env.PIX_ANTIGRAVITY_GOOGLE_CLIENT_SECRET ??
-  process.env.ANTIGRAVITY_GOOGLE_CLIENT_SECRET ??
-  "";
+const GOOGLE_CLIENT_ID = "";
+const GOOGLE_CLIENT_SECRET = "";
 
 // ============================================================================
 // 工具函数
@@ -258,9 +253,7 @@ async function refreshAccessToken(
   refreshToken: string,
 ): Promise<{ access_token: string; expires_in: number }> {
   if (!GOOGLE_CLIENT_ID || !GOOGLE_CLIENT_SECRET) {
-    throw new Error(
-      "Antigravity Google OAuth credentials are not configured; set PIX_ANTIGRAVITY_GOOGLE_CLIENT_ID and PIX_ANTIGRAVITY_GOOGLE_CLIENT_SECRET.",
-    );
+    throw new Error("Antigravity Google OAuth credentials are not bundled.");
   }
 
   const params = new URLSearchParams({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ui-extend",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "private": false,
   "type": "module",
   "bin": {

package/schemas/pi-tools-suite.json

@@ -16,6 +16,10 @@
       },
       "description": "List of disabled module names (e.g. ['lsp', 'prompt-commands'])."
     },
+    "todoThinking": {
+      "type": "boolean",
+      "description": "Enable per-todo thinking levels and automatic thinking switch/restore when tasks become in-progress/completed."
+    },
     "terminalBell": {
       "type": "object",
       "properties": {