topchester-ai 0.63.0 → 0.65.0

package/dist/bin.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as runTopchesterCli } from "./cli-fySUzvp-.mjs";
+import { t as runTopchesterCli } from "./cli-2v1iJ0YF.mjs";
 //#region src/bin.ts
 await runTopchesterCli();
 //#endregion

package/dist/{cli-fySUzvp-.mjs → cli-2v1iJ0YF.mjs}

@@ -1843,7 +1843,7 @@ async function deleteWorkspaceFile(workspaceRoot, path) {
 const finishTaskTool = defineTool({
 	name: "finish_task",
 	description: "Finish the current task only after the requested work has actually been completed with tools. Do not use this to claim edits, file reads, or validation that did not happen.",
-	prompt: "finish_task: complete the task with a brief final response only after tool results prove the work is done. For implementation tasks, do not call finish_task until source files were changed by edit_file, write_file, apply_patch, or another mutating tool, unless no code change is truly required. Example: {\"tool\":\"finish_task\",\"args\":{\"final_response\":\"Changed src/foo.ts and ran pnpm test foo.test.ts.\",\"files_changed\":[\"src/foo.ts\"],\"validation\":[\"pnpm test foo.test.ts\"],\"remaining_issues\":[]}}",
+	prompt: "finish_task: complete the task with a brief final response only after tool results prove the work is done. In benchmark or require-finish mode, this is the only valid terminal action; normal assistant messages are progress notes and do not finish the task. For implementation tasks, do not call finish_task until source files were changed by edit_file, write_file, apply_patch, or another mutating tool, unless no code change is truly required. Example: {\"tool\":\"finish_task\",\"args\":{\"final_response\":\"Changed src/foo.ts and ran pnpm test foo.test.ts.\",\"files_changed\":[\"src/foo.ts\"],\"validation\":[\"pnpm test foo.test.ts\"],\"remaining_issues\":[]}}",
 	argsSchema: z.object({
 		final_response: z.string().describe("Brief final response for the user."),
 		files_changed: z.array(z.string()).optional().describe("Workspace-relative files actually changed by successful edit tools."),
@@ -4083,7 +4083,7 @@ function truncateText(text, width) {
 const planTodoTool = defineTool({
 	name: "plan_todo",
 	description: "Replace the visible session task plan for multi-step work.",
-	prompt: "plan_todo: replace the visible session task plan for non-trivial multi-step work; keep 2-6 short items, exactly one in_progress item while work remains, and use [] only to clear. Do not use plan_todo just to report completed work before a final answer. To use it, reply with only JSON: {\"tool\":\"plan_todo\",\"args\":{\"items\":[{\"text\":\"Inspect relevant files\",\"status\":\"in_progress\"},{\"text\":\"Implement focused change\",\"status\":\"pending\"}]}}",
+	prompt: "plan_todo: replace the visible session task plan for genuinely multi-step work. Usually create it once after initial orientation, keep 2-6 short milestone items, exactly one in_progress item while work remains, and batch updates when milestones change. Do not call plan_todo twice in a row, after routine reads/searches, after failed edit attempts, for wording-only changes, or just to report completed work before a final answer. To use it, reply with only JSON: {\"tool\":\"plan_todo\",\"args\":{\"items\":[{\"text\":\"Inspect relevant files\",\"status\":\"in_progress\"},{\"text\":\"Implement focused change\",\"status\":\"pending\"}]}}",
 	argsSchema: planTodoArgsSchema,
 	async execute(context, args) {
 		if (!context.taskPlan) throw new Error("plan_todo requires runtime task-plan state.");
@@ -12390,8 +12390,10 @@ function getChatSystemPrompt(options = {}) {
 		"- Do not claim to have read, created, edited, staged, committed, or run anything unless a tool result in this turn confirms it.",
 		"- If the task requires implementation, do not finish with a prose summary before a successful source-editing tool result. A summary of intended changes is not a substitute for editing files.",
 		...canUseTool("plan_todo") ? [
-			"- Use plan_todo for non-trivial multi-step work before the first substantive repository tool call.",
-			"- Keep plan_todo items short, user-safe, and usually 2 to 6 items. Maintain exactly one in_progress item while work remains, update it after major progress changes, and clear it only when abandoning the plan or when no visible plan is useful.",
+			"- Use plan_todo for genuinely multi-step work when a visible checklist helps; for small or straightforward tasks, do the work directly.",
+			"- If you use plan_todo, usually create it once after initial orientation. Keep items short, user-safe, and usually 2 to 6 items with exactly one in_progress item while work remains.",
+			"- Batch plan_todo updates. Update only when a milestone completes, scope changes, or the next major phase starts; do not update after routine reads, searches, failed edit attempts, or wording-only changes.",
+			"- Never call plan_todo twice in a row.",
 			"- Do not use plan_todo for simple one-step answers, tiny reads, or trivial edits.",
 			"- Do not call plan_todo only to summarize completed work before a final answer. If no visible plan is active and the work is done, answer directly."
 		] : [],
@@ -12797,17 +12799,18 @@ function formatToolResultForPrompt(result) {
 }
 /**
 * Builds the follow-up instruction appended after each tool result. It keeps
-* the model on the active task, reminds it to maintain the visible plan, and
-* restates the current tool-call protocol so the next model step remains
-* parseable by the runtime.
+* the model on the active task, lightly references the visible plan when one
+* is active, and restates the current tool-call protocol so the next model
+* step remains parseable by the runtime.
 */
-function formatContinuationInstruction(protocol, result, canUsePlanTodo = true) {
+function formatContinuationInstruction(protocol, result, canUsePlanTodo = true, planTodoMode = "normal") {
 	const toolInstruction = protocol === "text-xml" ? "If another tool is needed, reply with only one XML tool call." : protocol === "text-json" ? "If another tool is needed, reply with only that tool JSON." : "If another tool is needed, use the available tool calling path.";
 	return [
 		"Continue the user's request using the tool result above and the visible plan when one is active.",
 		result.tool === "find_file" ? "find_file results are paths only; if the user asked to read or answer from file contents, call read_file on the relevant path before answering. Do not ask the user to provide the read_file result or permission." : "",
-		canUsePlanTodo ? "Update plan_todo after major progress changes." : "",
-		canUsePlanTodo ? "Before a final answer, close the visible plan by calling plan_todo with all finished items marked completed, or with [] if abandoning the plan." : "",
+		canUsePlanTodo && planTodoMode === "compact" ? "Compact plan mode is active: do not update plan_todo unless task scope materially changes; avoid final plan-closure calls." : "",
+		canUsePlanTodo && planTodoMode === "normal" ? "Use plan_todo sparingly: batch updates only when a milestone completes, scope changes, or the next major phase starts." : "",
+		canUsePlanTodo && planTodoMode === "normal" ? "Before a final answer, close the visible plan by calling plan_todo with all finished items marked completed, or with [] if abandoning the plan." : "",
 		toolInstruction,
 		"Otherwise answer the user. Do not guess."
 	].filter(Boolean).join(" ");
@@ -12852,6 +12855,22 @@ function formatNoEditCompletionFailure(draftAnswer) {
 	const trimmedDraft = draftAnswer.trim();
 	return ["I could not complete the implementation because no successful source-file edit occurred in this turn.", trimmedDraft ? `The model tried to finish with this unsupported summary:\n${trimmedDraft}` : ""].filter(Boolean).join("\n");
 }
+function formatFinishTaskRequiredRepairInstruction(protocol, draftAnswer) {
+	const toolInstruction = protocol === "text-xml" ? "Reply now with only one XML tool call for the next implementation or validation step, or call finish_task if the work is complete." : protocol === "text-json" ? "Reply now with only one tool JSON object for the next implementation or validation step, or call finish_task if the work is complete." : "Use the available tool calling path now for the next implementation or validation step, or call finish_task if the work is complete.";
+	const trimmedDraft = draftAnswer.trim();
+	return [
+		"This run requires finish_task as the only terminal action.",
+		"A normal assistant message is treated as a progress note, not completion.",
+		"Do not summarize next steps in prose. Use tools to perform the next step.",
+		"Call finish_task only when the requested work is complete and its files_changed, validation, and remaining_issues fields are accurate.",
+		toolInstruction,
+		trimmedDraft ? `Previous progress note that did not finish the task:\n${trimmedDraft}` : ""
+	].filter(Boolean).join("\n");
+}
+function formatFinishTaskRequiredFailure(draftAnswer) {
+	const trimmedDraft = draftAnswer.trim();
+	return ["I stopped because this run requires finish_task, but the model kept replying with normal assistant messages instead of using tools.", trimmedDraft ? `Last progress note:\n${trimmedDraft}` : ""].filter(Boolean).join("\n");
+}
 function getTextToolCallSources(protocol) {
 	return protocol === "text-xml" ? ["text-xml"] : protocol === "text-json" ? ["text-json"] : ["text-json", "text-xml"];
 }
@@ -13146,7 +13165,13 @@ function isCompletedPlanTodoItem(item) {
 }
 //#endregion
 //#region src/agent/runtime/index.ts
-const MAX_TOOL_CALLS_PER_TURN = 75;
+const DEFAULT_MAX_TOOL_CALLS_PER_TURN = 75;
+const MAX_TOOL_CALLS_PER_TURN_ENV = "TOPCHESTER_MAX_TOOL_CALLS_PER_TURN";
+const PLAN_TODO_MODE_ENV = "TOPCHESTER_PLAN_TODO_MODE";
+const MAX_PLAN_TODO_UPDATES_PER_TURN_ENV = "TOPCHESTER_MAX_PLAN_TODO_UPDATES_PER_TURN";
+const REQUIRE_FINISH_TASK_ENV = "TOPCHESTER_REQUIRE_FINISH_TASK";
+const DEFAULT_COMPACT_MAX_PLAN_TODO_UPDATES_PER_TURN = 3;
+const MAX_FINISH_TASK_REQUIRED_REPAIRS = 3;
 const DEFAULT_TASK_CONCURRENCY = 3;
 var TopchesterAgentRuntime = class TopchesterAgentRuntime {
 	context;
@@ -13273,12 +13298,18 @@ var TopchesterAgentRuntime = class TopchesterAgentRuntime {
 		let requestedPlanClosure = false;
 		let invalidToolCallRepairs = 0;
 		let noEditCompletionRepairs = 0;
+		let finishTaskRequiredRepairs = 0;
 		let hasSourceMutation = false;
+		const maxToolCallsPerTurn = readMaxToolCallsPerTurn();
+		const planTodoMode = readPlanTodoMode();
+		const maxPlanTodoUpdatesPerTurn = readMaxPlanTodoUpdatesPerTurn(planTodoMode);
+		let planTodoUpdates = 0;
 		const implementationTask = isImplementationTaskRequest(message);
+		const requireFinishTask = isFinishTaskRequiredByEnv() && isToolAllowed(permissions, "finish_task");
 		const projectInstructionToolState = { shownSourceKeys: /* @__PURE__ */ new Set() };
 		const persistedProjectInstructionKeys = /* @__PURE__ */ new Set();
 		try {
-			for (let toolCalls = 0; toolCalls <= MAX_TOOL_CALLS_PER_TURN; toolCalls += 1) {
+			for (let toolCalls = 0; toolCalls <= maxToolCallsPerTurn; toolCalls += 1) {
 				const startedAt = Date.now();
 				const projectInstructions = await this.resolveBaseProjectInstructions();
 				for (const event of createInstructionContextEventsFromProjectInstructions(projectInstructions, persistedProjectInstructionKeys)) yield event;
@@ -13385,7 +13416,19 @@ var TopchesterAgentRuntime = class TopchesterAgentRuntime {
 						yield agentEvent.status("ready");
 						return;
 					}
-					if (hasOpenTaskPlan(plan)) {
+					if (requireFinishTask) {
+						if (finishTaskRequiredRepairs < MAX_FINISH_TASK_REQUIRED_REPAIRS) {
+							finishTaskRequiredRepairs += 1;
+							nextPrompt = `${nextPrompt}\n\n${formatFinishTaskRequiredRepairInstruction(result.toolProtocol, finalText)}`;
+							continue;
+						}
+						const finalMessage = formatFinishTaskRequiredFailure(finalText);
+						yield agentEvent.assistantMessage(finalMessage, formatAgentMessageMeta(result.modelId, totalDurationMs, tokenUsageTotals));
+						for await (const event of this.streamStopHookEvents(session, finalMessage, "failed", abortSignal)) yield event;
+						yield agentEvent.status("ready");
+						return;
+					}
+					if (planTodoMode === "normal" && hasOpenTaskPlan(plan)) {
 						if (!requestedPlanClosure) {
 							requestedPlanClosure = true;
 							nextPrompt = `${nextPrompt}\n\n${formatOpenPlanClosureInstruction(finalText, result.toolProtocol)}`;
@@ -13399,11 +13442,11 @@ var TopchesterAgentRuntime = class TopchesterAgentRuntime {
 					yield agentEvent.status("ready");
 					return;
 				}
-				if (toolCalls === MAX_TOOL_CALLS_PER_TURN) {
+				if (toolCalls === maxToolCallsPerTurn) {
 					yield agentEvent.choice({
 						tone: "warning",
 						title: "Tool call limit reached",
-						body: `Stopped after ${MAX_TOOL_CALLS_PER_TURN} tool calls in one turn. Continue starts another turn; abort leaves the call stopped.`,
+						body: `Stopped after ${maxToolCallsPerTurn} tool calls in one turn. Continue starts another turn; abort leaves the call stopped.`,
 						actions: [choiceAction("Continue", "Continue the previous task from where you stopped."), choiceAction("Abort", ABORT_CHOICE_VALUE)]
 					});
 					yield agentEvent.status("ready");
@@ -13481,7 +13524,7 @@ var TopchesterAgentRuntime = class TopchesterAgentRuntime {
 						}
 					}
 					afterTool = "task";
-					nextPrompt = this.appendRuntimeSteeringToContinuationPrompt(this.appendHookContextsToPrompt(`${nextPrompt}\n\n${taskResults.map((toolResult) => formatToolResultForPrompt(toolResult)).join("\n\n")}\n\n${formatContinuationInstruction(result.toolProtocol, taskResults.at(-1), isToolAllowed(permissions, "plan_todo"))}`, "PostToolUse", postHookContexts), options.steering);
+					nextPrompt = this.appendRuntimeSteeringToContinuationPrompt(this.appendHookContextsToPrompt(`${nextPrompt}\n\n${taskResults.map((toolResult) => formatToolResultForPrompt(toolResult)).join("\n\n")}\n\n${formatContinuationInstruction(result.toolProtocol, taskResults.at(-1), isToolAllowed(permissions, "plan_todo"), planTodoMode)}`, "PostToolUse", postHookContexts), options.steering);
 					continue;
 				}
 				if (modelToolCalls.length > 1 && modelToolCalls.every((call) => toolCatalog.isParallelSafe(call.tool))) {
@@ -13545,7 +13588,7 @@ var TopchesterAgentRuntime = class TopchesterAgentRuntime {
 						}
 					}
 					afterTool = parallelCalls.at(-1)?.tool;
-					nextPrompt = this.appendRuntimeSteeringToContinuationPrompt(this.appendHookContextsToPrompt(`${nextPrompt}\n\n${parallelResults.map((toolResult) => formatToolResultForPrompt(toolResult)).join("\n\n")}\n\n${formatContinuationInstruction(result.toolProtocol, parallelResults.at(-1), isToolAllowed(permissions, "plan_todo"))}`, "PostToolUse", postHookContexts), options.steering);
+					nextPrompt = this.appendRuntimeSteeringToContinuationPrompt(this.appendHookContextsToPrompt(`${nextPrompt}\n\n${parallelResults.map((toolResult) => formatToolResultForPrompt(toolResult)).join("\n\n")}\n\n${formatContinuationInstruction(result.toolProtocol, parallelResults.at(-1), isToolAllowed(permissions, "plan_todo"), planTodoMode)}`, "PostToolUse", postHookContexts), options.steering);
 					continue;
 				}
 				const executableToolCall = toolCall;
@@ -13557,47 +13600,55 @@ var TopchesterAgentRuntime = class TopchesterAgentRuntime {
 					yield agentEvent.status("ready");
 					return;
 				}
-				const preHookRun = this.startPreToolUseHook(executableToolCall, toolCall.id, session, abortSignal);
-				for await (const event of preHookRun.statusEvents) yield event;
-				const preHook = await preHookRun.result;
-				for (const event of this.hookResultToEvents(preHook)) yield event;
 				let toolResult;
-				if (preHook.stopped) {
-					if (preHook.messages.length === 0) yield agentEvent.systemMessage(preHook.stopped.message);
-					yield agentEvent.status("ready");
-					return;
-				}
-				if (preHook.blocked) toolResult = createToolErrorResult(executableToolCall.tool, preHook.blocked.message);
+				const planTodoRejection = validatePlanTodoCall(executableToolCall, this.taskPlan.get(), {
+					afterTool,
+					planTodoUpdates,
+					maxPlanTodoUpdatesPerTurn
+				});
+				if (planTodoRejection) toolResult = createToolErrorResult(executableToolCall.tool, planTodoRejection);
 				else {
-					const approval = await this.resolveBashApproval(executableToolCall, toolCall.id, options, session, abortSignal);
-					for (const event of approval.events) yield event;
-					if (approval.cancelled && approval.stopped) {
-						if (!approval.events.some((event) => event.type === "message" && event.text === approval.reason)) yield agentEvent.systemMessage(approval.reason);
+					const preHookRun = this.startPreToolUseHook(executableToolCall, toolCall.id, session, abortSignal);
+					for await (const event of preHookRun.statusEvents) yield event;
+					const preHook = await preHookRun.result;
+					for (const event of this.hookResultToEvents(preHook)) yield event;
+					if (preHook.stopped) {
+						if (preHook.messages.length === 0) yield agentEvent.systemMessage(preHook.stopped.message);
 						yield agentEvent.status("ready");
 						return;
 					}
-					if (approval.cancelled) toolResult = createToolErrorResult(executableToolCall.tool, approval.reason);
+					if (preHook.blocked) toolResult = createToolErrorResult(executableToolCall.tool, preHook.blocked.message);
 					else {
-						const toolEventQueue = createRuntimeEventQueue();
-						const toolResultPromise = executeToolCall(this.context.workspaceRoot, executableToolCall, {
-							logger: this.context.logger,
-							config: this.context.config,
-							bashApprovals: { allowExactCommands: approval.approvedCommands },
-							taskPlan: this.taskPlan,
-							profile,
-							permissions,
-							subagents,
-							projectInstructions: projectInstructionToolState,
-							currentUserMessage: message,
-							abortSignal,
-							toolCallId: toolCall.id,
-							toolCatalog,
-							eventSink: (event) => toolEventQueue.push(event)
-						}).finally(() => {
-							toolEventQueue.close();
-						});
-						for await (const event of toolEventQueue) yield event;
-						toolResult = await toolResultPromise;
+						const approval = await this.resolveBashApproval(executableToolCall, toolCall.id, options, session, abortSignal);
+						for (const event of approval.events) yield event;
+						if (approval.cancelled && approval.stopped) {
+							if (!approval.events.some((event) => event.type === "message" && event.text === approval.reason)) yield agentEvent.systemMessage(approval.reason);
+							yield agentEvent.status("ready");
+							return;
+						}
+						if (approval.cancelled) toolResult = createToolErrorResult(executableToolCall.tool, approval.reason);
+						else {
+							const toolEventQueue = createRuntimeEventQueue();
+							const toolResultPromise = executeToolCall(this.context.workspaceRoot, executableToolCall, {
+								logger: this.context.logger,
+								config: this.context.config,
+								bashApprovals: { allowExactCommands: approval.approvedCommands },
+								taskPlan: this.taskPlan,
+								profile,
+								permissions,
+								subagents,
+								projectInstructions: projectInstructionToolState,
+								currentUserMessage: message,
+								abortSignal,
+								toolCallId: toolCall.id,
+								toolCatalog,
+								eventSink: (event) => toolEventQueue.push(event)
+							}).finally(() => {
+								toolEventQueue.close();
+							});
+							for await (const event of toolEventQueue) yield event;
+							toolResult = await toolResultPromise;
+						}
 					}
 				}
 				for (const event of createInstructionContextEventsFromToolResult(toolResult, persistedProjectInstructionKeys)) yield event;
@@ -13605,14 +13656,17 @@ var TopchesterAgentRuntime = class TopchesterAgentRuntime {
 					const finishError = validateFinishTaskResult(toolResult, {
 						implementationTask,
 						hasSourceMutation,
-						hasOpenPlan: hasOpenTaskPlan(this.taskPlan.get()),
+						hasOpenPlan: planTodoMode === "normal" && hasOpenTaskPlan(this.taskPlan.get()),
 						canUseSourceEditTool: canStillUseSourceEditTool(permissions)
 					});
 					if (finishError) toolResult = createToolErrorResult(executableToolCall.tool, finishError);
 				}
 				if (isSourceMutationResult(toolResult)) hasSourceMutation = true;
 				yield agentEvent.toolCall(executableToolCall, formatToolCallMessage(executableToolCall, toolResult), getToolCallDisplayDiff(toolResult));
-				if (!isToolErrorResult(toolResult) && toolResult.tool === "plan_todo") yield agentEvent.taskPlan(toolResult.plan);
+				if (!isToolErrorResult(toolResult) && toolResult.tool === "plan_todo") {
+					planTodoUpdates += 1;
+					yield agentEvent.taskPlan(toolResult.plan);
+				}
 				const postHookRun = this.startPostToolUseHook(executableToolCall, toolCall.id, toolResult, session, abortSignal);
 				for await (const event of postHookRun.statusEvents) yield event;
 				const postHook = await postHookRun.result;
@@ -13630,7 +13684,7 @@ var TopchesterAgentRuntime = class TopchesterAgentRuntime {
 					return;
 				}
 				afterTool = executableToolCall.tool;
-				nextPrompt = this.appendRuntimeSteeringToContinuationPrompt(this.appendHookContextsToPrompt(`${nextPrompt}\n\n${formatToolResultForPrompt(toolResult)}\n\n${formatContinuationInstruction(result.toolProtocol, toolResult, isToolAllowed(permissions, "plan_todo"))}`, "PostToolUse", postHook.contexts), options.steering);
+				nextPrompt = this.appendRuntimeSteeringToContinuationPrompt(this.appendHookContextsToPrompt(`${nextPrompt}\n\n${formatToolResultForPrompt(toolResult)}\n\n${formatContinuationInstruction(result.toolProtocol, toolResult, isToolAllowed(permissions, "plan_todo"), planTodoMode)}`, "PostToolUse", postHook.contexts), options.steering);
 			}
 			const finalMessage = "I stopped because the tool loop ended unexpectedly.";
 			yield agentEvent.assistantMessage(finalMessage, formatAgentMessageMeta(lastModelId, totalDurationMs, tokenUsageTotals));
@@ -14014,6 +14068,50 @@ function getToolCallDisplayDiff(result) {
 	if (result.tool === "edit_file" && !isToolErrorResult(result) && "diff" in result) return result.diff;
 	if (result.tool === "apply_patch" && !isToolErrorResult(result) && result.diffs.length > 0) return result.diffs.join("\n");
 }
+function readMaxToolCallsPerTurn() {
+	const raw = process.env[MAX_TOOL_CALLS_PER_TURN_ENV]?.trim();
+	if (!raw) return DEFAULT_MAX_TOOL_CALLS_PER_TURN;
+	const parsed = Number(raw);
+	if (!Number.isInteger(parsed) || parsed <= 0) return DEFAULT_MAX_TOOL_CALLS_PER_TURN;
+	return parsed;
+}
+function readPlanTodoMode() {
+	return process.env[PLAN_TODO_MODE_ENV]?.trim().toLowerCase() === "compact" ? "compact" : "normal";
+}
+function isFinishTaskRequiredByEnv() {
+	const raw = process.env[REQUIRE_FINISH_TASK_ENV]?.trim().toLowerCase();
+	return raw === "1" || raw === "true" || raw === "yes" || raw === "on";
+}
+function readMaxPlanTodoUpdatesPerTurn(mode) {
+	const raw = process.env[MAX_PLAN_TODO_UPDATES_PER_TURN_ENV]?.trim();
+	if (!raw) return mode === "compact" ? DEFAULT_COMPACT_MAX_PLAN_TODO_UPDATES_PER_TURN : void 0;
+	const parsed = Number(raw);
+	if (!Number.isInteger(parsed) || parsed < 0) return mode === "compact" ? DEFAULT_COMPACT_MAX_PLAN_TODO_UPDATES_PER_TURN : void 0;
+	return parsed;
+}
+function validatePlanTodoCall(call, currentPlan, state) {
+	if (call.tool !== "plan_todo") return;
+	const allCompleted = isAllCompletedPlanTodoCall(call.args);
+	if (state.afterTool === "plan_todo" && !allCompleted) return "plan_todo rejected because the previous tool call was also plan_todo. Batch checklist updates and proceed with repository work.";
+	if (state.maxPlanTodoUpdatesPerTurn !== void 0 && state.planTodoUpdates >= state.maxPlanTodoUpdatesPerTurn) return `plan_todo rejected because this turn already used ${state.planTodoUpdates} plan update(s), which meets the configured limit of ${state.maxPlanTodoUpdatesPerTurn}. Continue with repository work and summarize progress in the final response.`;
+	if (isSamePlanTodoItems(call.args, currentPlan) && !allCompleted) return "plan_todo rejected because it does not change the visible plan. Continue with the next substantive tool call or final response.";
+}
+function isAllCompletedPlanTodoCall(args) {
+	const items = args.items;
+	return Array.isArray(items) && items.length > 0 && items.every((item) => {
+		return Boolean(item && typeof item === "object" && "status" in item && item.status === "completed");
+	});
+}
+function isSamePlanTodoItems(args, currentPlan) {
+	const items = args.items;
+	if (!Array.isArray(items) || items.length !== currentPlan.items.length) return false;
+	return items.every((item, index) => {
+		const current = currentPlan.items[index];
+		if (!current || typeof item !== "object" || item === null) return false;
+		const candidate = item;
+		return candidate.text === current.text && candidate.status === current.status;
+	});
+}
 function isImplementationTaskRequest(message) {
 	return /\b(implement|complete|fix|add|update|change|modify|refactor|write|create|wire|hook|support|benchmark|task end-to-end)\b/iu.test(message);
 }
@@ -16431,4 +16529,4 @@ function formatDryRunSyncStatus(status) {
 //#endregion
 export { runTopchesterCli as t };
 
-//# sourceMappingURL=cli-fySUzvp-.mjs.map
+//# sourceMappingURL=cli-2v1iJ0YF.mjs.map