xtrm-tools 0.5.0

package/config/pi/extensions/minimal-mode/index.ts

@@ -0,0 +1,201 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import {
+	createBashTool,
+	createEditTool,
+	createFindTool,
+	createGrepTool,
+	createLsTool,
+	createReadTool,
+	createWriteTool,
+} from "@mariozechner/pi-coding-agent";
+import { Text } from "@mariozechner/pi-tui";
+
+function getTextContent(result: any): string {
+	if (!result?.content || !Array.isArray(result.content)) return "";
+	return result.content
+		.filter((c: any) => c?.type === "text" && typeof c.text === "string")
+		.map((c: any) => c.text)
+		.join("\n")
+		.trim();
+}
+
+function oneLine(s: string): string {
+	return (s || "").replace(/\s+/g, " ").trim();
+}
+
+function summarize(result: any): { text: string; isError: boolean } {
+	const raw = getTextContent(result);
+	if (!raw) return { text: "done", isError: false };
+	const line = oneLine(raw.split("\n").find((l) => l.trim()) || "");
+	const lower = line.toLowerCase();
+	const isError = lower.includes("error") || lower.includes("failed") || lower.includes("exception");
+	return { text: line.slice(0, 140) || "done", isError };
+}
+
+const toolCache = new Map<string, ReturnType<typeof createBuiltInTools>>();
+function createBuiltInTools(cwd: string) {
+	return {
+		read: createReadTool(cwd),
+		bash: createBashTool(cwd),
+		edit: createEditTool(cwd),
+		write: createWriteTool(cwd),
+		find: createFindTool(cwd),
+		grep: createGrepTool(cwd),
+		ls: createLsTool(cwd),
+	};
+}
+function getBuiltInTools(cwd: string) {
+	let tools = toolCache.get(cwd);
+	if (!tools) {
+		tools = createBuiltInTools(cwd);
+		toolCache.set(cwd, tools);
+	}
+	return tools;
+}
+
+export default function (pi: ExtensionAPI) {
+	let minimalEnabled = true;
+	let thinkingStatusEnabled = true;
+	let spinnerTimer: NodeJS.Timeout | null = null;
+	let spinnerIndex = 0;
+	const frames = ["thinking   ", "thinking.  ", "thinking.. ", "thinking..."];
+
+	const clearSpinner = (ctx: any) => {
+		if (spinnerTimer) {
+			clearInterval(spinnerTimer);
+			spinnerTimer = null;
+		}
+		if (ctx?.hasUI) {
+			ctx.ui.setStatus("thinking", undefined);
+			ctx.ui.setHeader(undefined);
+		}
+	};
+
+	const mountThinkingHeader = (ctx: any) => {
+		if (!ctx?.hasUI) return;
+		ctx.ui.setHeader((_tui: any, theme: any) => ({
+			invalidate() {},
+			render(width: number): string[] {
+				const text = frames[spinnerIndex];
+				return [oneLine(theme.fg("accent", text)).slice(0, width)];
+			},
+		}));
+	};
+
+	const startSpinner = (ctx: any) => {
+		if (!thinkingStatusEnabled || !ctx?.hasUI) return;
+		clearSpinner(ctx);
+		spinnerIndex = 0;
+		ctx.ui.setStatus("thinking", frames[spinnerIndex]);
+		mountThinkingHeader(ctx);
+		spinnerTimer = setInterval(() => {
+			spinnerIndex = (spinnerIndex + 1) % frames.length;
+			ctx.ui.setStatus("thinking", frames[spinnerIndex]);
+			mountThinkingHeader(ctx);
+		}, 220);
+	};
+
+	const renderCollapsedResult = (result: any, theme: any) => {
+		const s = summarize(result);
+		const icon = s.isError ? theme.fg("error", "✗") : theme.fg("success", "✓");
+		const text = s.isError ? theme.fg("error", s.text) : theme.fg("muted", s.text);
+		if (minimalEnabled) return new Text(` ${icon} ${text}`, 0, 0);
+		return new Text(theme.fg("muted", ` → ${s.text}`), 0, 0);
+	};
+
+	const renderExpandedResult = (result: any, theme: any) => {
+		const text = getTextContent(result);
+		if (!text) return new Text("", 0, 0);
+		const output = text.split("\n").map((line) => theme.fg("toolOutput", line)).join("\n");
+		return new Text(`\n${output}`, 0, 0);
+	};
+
+	pi.registerTool({
+		name: "bash",
+		label: "bash",
+		description: getBuiltInTools(process.cwd()).bash.description,
+		parameters: getBuiltInTools(process.cwd()).bash.parameters,
+		async execute(toolCallId, params, signal, onUpdate, ctx) {
+			return getBuiltInTools(ctx.cwd).bash.execute(toolCallId, params, signal, onUpdate);
+		},
+		renderCall(args, theme) {
+			const cmd = oneLine(args.command || "");
+			return new Text(`${theme.fg("toolTitle", theme.bold("bash"))}(${theme.fg("accent", cmd || "...")})`, 0, 0);
+		},
+		renderResult(result, { expanded }, theme) {
+			return expanded ? renderExpandedResult(result, theme) : renderCollapsedResult(result, theme);
+		},
+	});
+
+	for (const name of ["read", "write", "edit", "find", "grep", "ls"] as const) {
+		pi.registerTool({
+			name,
+			label: name,
+			description: (getBuiltInTools(process.cwd()) as any)[name].description,
+			parameters: (getBuiltInTools(process.cwd()) as any)[name].parameters,
+			async execute(toolCallId, params, signal, onUpdate, ctx) {
+				return (getBuiltInTools(ctx.cwd) as any)[name].execute(toolCallId, params, signal, onUpdate);
+			},
+			renderCall(args, theme) {
+				const suffix = oneLine(args.path || args.pattern || "");
+				return new Text(`${theme.fg("toolTitle", theme.bold(name))}${suffix ? `(${theme.fg("accent", suffix)})` : ""}`, 0, 0);
+			},
+			renderResult(result, { expanded }, theme) {
+				return expanded ? renderExpandedResult(result, theme) : renderCollapsedResult(result, theme);
+			},
+		});
+	}
+
+	pi.registerCommand("minimal-on", {
+		description: "Enable minimal collapsed tool output",
+		handler: async (_args, ctx) => {
+			minimalEnabled = true;
+			ctx.ui.notify("Minimal mode enabled", "info");
+		},
+	});
+
+	pi.registerCommand("minimal-off", {
+		description: "Disable minimal collapsed tool output",
+		handler: async (_args, ctx) => {
+			minimalEnabled = false;
+			ctx.ui.notify("Minimal mode disabled", "info");
+		},
+	});
+
+	pi.registerCommand("minimal-toggle", {
+		description: "Toggle minimal collapsed tool output",
+		handler: async (_args, ctx) => {
+			minimalEnabled = !minimalEnabled;
+			ctx.ui.notify(`Minimal mode ${minimalEnabled ? "enabled" : "disabled"}`, "info");
+		},
+	});
+
+	pi.registerCommand("thinking-status-toggle", {
+		description: "Toggle flashing thinking status indicator",
+		handler: async (_args, ctx) => {
+			thinkingStatusEnabled = !thinkingStatusEnabled;
+			if (!thinkingStatusEnabled) clearSpinner(ctx);
+			ctx.ui.notify(`Thinking status ${thinkingStatusEnabled ? "enabled" : "disabled"}`, "info");
+		},
+	});
+
+	pi.on("turn_start", async (_event, ctx) => {
+		startSpinner(ctx);
+		return undefined;
+	});
+
+	pi.on("turn_end", async (_event, ctx) => {
+		clearSpinner(ctx);
+		return undefined;
+	});
+
+	pi.on("agent_end", async (_event, ctx) => {
+		clearSpinner(ctx);
+		return undefined;
+	});
+
+	pi.on("session_shutdown", async (_event, ctx) => {
+		clearSpinner(ctx);
+		return undefined;
+	});
+}

package/config/pi/extensions/minimal-mode/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@xtrm/pi-minimal-mode",
+  "version": "1.0.0",
+  "description": "xtrm Pi extension: minimal-mode",
+  "type": "module",
+  "exports": {
+    ".": "./index.ts"
+  },
+  "keywords": [
+    "pi",
+    "extension",
+    "xtrm"
+  ],
+  "author": "xtrm",
+  "license": "MIT"
+}

package/config/pi/extensions/plan-mode/README.md

@@ -0,0 +1,65 @@
+# Plan Mode Extension
+
+Read-only exploration mode for safe code analysis.
+
+## Features
+
+- **Read-only tools**: Restricts available tools to read, bash, grep, find, ls, question
+- **Bash allowlist**: Only read-only bash commands are allowed
+- **Plan extraction**: Extracts numbered steps from `Plan:` sections
+- **Progress tracking**: Widget shows completion status during execution
+- **[DONE:n] markers**: Explicit step completion tracking
+- **Session persistence**: State survives session resume
+
+## Commands
+
+- `/plan` - Toggle plan mode
+- `/todos` - Show current plan progress
+- `Ctrl+Alt+P` - Toggle plan mode (shortcut)
+
+## Usage
+
+1. Enable plan mode with `/plan` or `--plan` flag
+2. Ask the agent to analyze code and create a plan
+3. The agent should output a numbered plan under a `Plan:` header:
+
+```
+Plan:
+1. First step description
+2. Second step description
+3. Third step description
+```
+
+4. Choose "Execute the plan" when prompted
+5. During execution, the agent marks steps complete with `[DONE:n]` tags
+6. Progress widget shows completion status
+
+## How It Works
+
+### Plan Mode (Read-Only)
+- Only read-only tools available
+- Bash commands filtered through allowlist
+- Agent creates a plan without making changes
+
+### Execution Mode
+- Full tool access restored
+- Agent executes steps in order
+- `[DONE:n]` markers track completion
+- Widget shows progress
+
+### Command Allowlist
+
+Safe commands (allowed):
+- File inspection: `cat`, `head`, `tail`, `less`, `more`
+- Search: `grep`, `find`, `rg`, `fd`
+- Directory: `ls`, `pwd`, `tree`
+- Git read: `git status`, `git log`, `git diff`, `git branch`
+- Package info: `npm list`, `npm outdated`, `yarn info`
+- System info: `uname`, `whoami`, `date`, `uptime`
+
+Blocked commands:
+- File modification: `rm`, `mv`, `cp`, `mkdir`, `touch`
+- Git write: `git add`, `git commit`, `git push`
+- Package install: `npm install`, `yarn add`, `pip install`
+- System: `sudo`, `kill`, `reboot`
+- Editors: `vim`, `nano`, `code`

package/config/pi/extensions/plan-mode/index.ts

@@ -0,0 +1,417 @@
+/**
+ * Plan Mode Extension
+ *
+ * Read-only exploration mode for safe code analysis.
+ * When enabled, only read-only tools are available.
+ *
+ * Features:
+ * - /plan command or Ctrl+Alt+P to toggle
+ * - Bash restricted to allowlisted read-only commands
+ * - Extracts numbered plan steps from "Plan:" sections
+ * - [DONE:n] markers to complete steps during execution
+ * - Progress tracking widget during execution
+ */
+
+import type { AgentMessage } from "@mariozechner/pi-agent-core";
+import type { AssistantMessage, TextContent } from "@mariozechner/pi-ai";
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { Key } from "@mariozechner/pi-tui";
+import {
+	extractTodoItems,
+	isSafeCommand,
+	markCompletedSteps,
+	type TodoItem,
+	getShortId,
+	isBeadsProject,
+	deriveEpicTitle,
+	createPlanIssues,
+	bdClaim,
+} from "./utils.js";
+
+// Tools
+const PLAN_MODE_TOOLS = ["read", "bash", "grep", "find", "ls", "questionnaire"];
+const NORMAL_MODE_TOOLS = ["read", "bash", "edit", "write"];
+
+// Type guard for assistant messages
+function isAssistantMessage(m: AgentMessage): m is AssistantMessage {
+	return m.role === "assistant" && Array.isArray(m.content);
+}
+
+// Extract text content from an assistant message
+function getTextContent(message: AssistantMessage): string {
+	return message.content
+		.filter((block): block is TextContent => block.type === "text")
+		.map((block) => block.text)
+		.join("\n");
+}
+
+export default function planModeExtension(pi: ExtensionAPI): void {
+	let planModeEnabled = false;
+	let executionMode = false;
+	let todoItems: TodoItem[] = [];
+	let epicId: string | null = null;
+	let issueIds: Map<number, string> = new Map(); // step -> issue ID
+
+	pi.registerFlag("plan", {
+		description: "Start in plan mode (read-only exploration)",
+		type: "boolean",
+		default: false,
+	});
+
+	function updateStatus(ctx: ExtensionContext): void {
+		// Footer status
+		if (executionMode && todoItems.length > 0) {
+			const completed = todoItems.filter((t) => t.completed).length;
+			ctx.ui.setStatus("plan-mode", ctx.ui.theme.fg("accent", `📋 ${completed}/${todoItems.length}`));
+		} else if (planModeEnabled) {
+			ctx.ui.setStatus("plan-mode", ctx.ui.theme.fg("warning", "⏸ plan"));
+		} else {
+			ctx.ui.setStatus("plan-mode", undefined);
+		}
+
+		// Widget showing todo list with bd issue IDs
+		if (executionMode && todoItems.length > 0) {
+			const lines = todoItems.map((item) => {
+				const issueId = issueIds.get(item.step);
+				const idLabel = issueId ? `[${getShortId(issueId)}] ` : "";
+				if (item.completed) {
+					return (
+						ctx.ui.theme.fg("success", "☑ ") + ctx.ui.theme.fg("muted", ctx.ui.theme.strikethrough(`${idLabel}${item.text}`))
+					);
+				}
+				return `${ctx.ui.theme.fg("muted", "☐ ")}${idLabel}${item.text}`;
+			});
+			ctx.ui.setWidget("plan-todos", lines);
+		} else {
+			ctx.ui.setWidget("plan-todos", undefined);
+		}
+	}
+
+	function togglePlanMode(ctx: ExtensionContext): void {
+		planModeEnabled = !planModeEnabled;
+		executionMode = false;
+		todoItems = [];
+		epicId = null;
+		issueIds.clear();
+
+		if (planModeEnabled) {
+			pi.setActiveTools(PLAN_MODE_TOOLS);
+			ctx.ui.notify(`Plan mode enabled. Tools: ${PLAN_MODE_TOOLS.join(", ")}`);
+		} else {
+			pi.setActiveTools(NORMAL_MODE_TOOLS);
+			ctx.ui.notify("Plan mode disabled. Full access restored.");
+		}
+		updateStatus(ctx);
+	}
+
+	function persistState(): void {
+		pi.appendEntry("plan-mode", {
+			enabled: planModeEnabled,
+			todos: todoItems,
+			executing: executionMode,
+			epicId,
+			issueIds: Object.fromEntries(issueIds),
+		});
+	}
+
+	pi.registerCommand("plan", {
+		description: "Toggle plan mode (read-only exploration)",
+		handler: async (_args, ctx) => togglePlanMode(ctx),
+	});
+
+	pi.registerCommand("todos", {
+		description: "Show current plan todo list",
+		handler: async (_args, ctx) => {
+			if (todoItems.length === 0) {
+				ctx.ui.notify("No todos. Create a plan first with /plan", "info");
+				return;
+			}
+			const list = todoItems.map((item, i) => {
+				const issueId = issueIds.get(item.step);
+				const idLabel = issueId ? `[${getShortId(issueId)}] ` : "";
+				return `${i + 1}. ${item.completed ? "✓" : "○"} ${idLabel}${item.text}`;
+			}).join("\n");
+			ctx.ui.notify(`Plan Progress:\n${list}`, "info");
+		},
+	});
+
+	pi.registerShortcut(Key.ctrlAlt("p"), {
+		description: "Toggle plan mode",
+		handler: async (ctx) => togglePlanMode(ctx),
+	});
+
+	// Block destructive bash commands in plan mode
+	pi.on("tool_call", async (event) => {
+		if (!planModeEnabled || event.toolName !== "bash") return;
+
+		const command = event.input.command as string;
+		if (!isSafeCommand(command)) {
+			return {
+				block: true,
+				reason: `Plan mode: command blocked (not allowlisted). Use /plan to disable plan mode first.\nCommand: ${command}`,
+			};
+		}
+	});
+
+	// Filter out stale plan mode context when not in plan mode
+	pi.on("context", async (event) => {
+		if (planModeEnabled) return;
+
+		return {
+			messages: event.messages.filter((m) => {
+				const msg = m as AgentMessage & { customType?: string };
+				if (msg.customType === "plan-mode-context") return false;
+				if (msg.role !== "user") return true;
+
+				const content = msg.content;
+				if (typeof content === "string") {
+					return !content.includes("[PLAN MODE ACTIVE]");
+				}
+				if (Array.isArray(content)) {
+					return !content.some(
+						(c) => c.type === "text" && (c as TextContent).text?.includes("[PLAN MODE ACTIVE]"),
+					);
+				}
+				return true;
+			}),
+		};
+	});
+
+	// Inject plan/execution context before agent starts
+	pi.on("before_agent_start", async () => {
+		if (planModeEnabled) {
+			return {
+				message: {
+					customType: "plan-mode-context",
+					content: `[PLAN MODE ACTIVE]
+You are in plan mode - a read-only exploration mode for safe code analysis.
+
+Restrictions:
+- You can only use: read, bash, grep, find, ls, questionnaire
+- You CANNOT use: edit, write (file modifications are disabled)
+- Bash is restricted to an allowlist of read-only commands
+
+Ask clarifying questions using the questionnaire tool.
+Use brave-search skill via bash for web research.
+
+Create a detailed numbered plan under a "Plan:" header:
+
+Plan:
+1. First step description
+2. Second step description
+...
+
+Do NOT attempt to make changes - just describe what you would do.`,
+					display: false,
+				},
+			};
+		}
+
+		if (executionMode && todoItems.length > 0) {
+			const remaining = todoItems.filter((t) => !t.completed);
+			const todoList = remaining.map((t) => {
+				const issueId = issueIds.get(t.step);
+				const idLabel = issueId ? `[${getShortId(issueId)}] ` : "";
+				return `${t.step}. ${idLabel}${t.text}`;
+			}).join("\n");
+			return {
+				message: {
+					customType: "plan-execution-context",
+					content: `[EXECUTING PLAN - Full tool access enabled]
+
+Remaining steps:
+${todoList}
+
+Execute each step in order.
+After completing a step, include a [DONE:n] tag in your response.`,
+					display: false,
+				},
+			};
+		}
+	});
+
+	// Track progress after each turn
+	pi.on("turn_end", async (event, ctx) => {
+		if (!executionMode || todoItems.length === 0) return;
+		if (!isAssistantMessage(event.message)) return;
+
+		const text = getTextContent(event.message);
+		if (markCompletedSteps(text, todoItems) > 0) {
+			updateStatus(ctx);
+		}
+		persistState();
+	});
+
+	// Handle plan completion and plan mode UI
+	pi.on("agent_end", async (event, ctx) => {
+		// Check if execution is complete
+		if (executionMode && todoItems.length > 0) {
+			if (todoItems.every((t) => t.completed)) {
+				const completedList = todoItems.map((t) => {
+					const issueId = issueIds.get(t.step);
+					const idLabel = issueId ? `[${getShortId(issueId)}] ` : "";
+					return `~~${idLabel}${t.text}~~`;
+				}).join("\n");
+				pi.sendMessage(
+					{ customType: "plan-complete", content: `**Plan Complete!** ✓\n\n${completedList}`, display: true },
+					{ triggerTurn: false },
+				);
+				executionMode = false;
+				todoItems = [];
+				epicId = null;
+				issueIds.clear();
+				pi.setActiveTools(NORMAL_MODE_TOOLS);
+				updateStatus(ctx);
+				persistState(); // Save cleared state so resume doesn't restore old execution mode
+			}
+			return;
+		}
+
+		if (!planModeEnabled || !ctx.hasUI) return;
+
+		// Extract todos from last assistant message
+		const lastAssistant = [...event.messages].reverse().find(isAssistantMessage);
+		if (lastAssistant) {
+			const extracted = extractTodoItems(getTextContent(lastAssistant));
+			if (extracted.length > 0) {
+				todoItems = extracted;
+			}
+		}
+
+		// Auto-create epic + issues if in a beads project
+		const cwd = ctx.cwd || process.cwd();
+		if (todoItems.length > 0 && isBeadsProject(cwd) && !epicId) {
+			// Derive epic title from user prompt or first step
+			const epicTitle = deriveEpicTitle(event.messages);
+			
+			ctx.ui.notify("Creating epic and issues in bd...", "info");
+			const result = await createPlanIssues(epicTitle, todoItems, cwd);
+			
+			if (result) {
+				epicId = result.epic.id;
+				for (const issue of result.issues) {
+					// Match issue to todo by title similarity
+					const matchingTodo = todoItems.find(t => 
+						issue.title.toLowerCase().includes(t.text.toLowerCase().slice(0, 30)) ||
+						t.text.toLowerCase().includes(issue.title.toLowerCase().slice(0, 30))
+					);
+					if (matchingTodo) {
+						issueIds.set(matchingTodo.step, issue.id);
+					}
+				}
+				ctx.ui.notify(`Created epic ${getShortId(epicId)} with ${result.issues.length} issues`, "info");
+			}
+		}
+
+		// Show plan steps with bd issue IDs
+		if (todoItems.length > 0) {
+			const todoListText = todoItems.map((t, i) => {
+				const issueId = issueIds.get(t.step);
+				const idLabel = issueId ? `[${getShortId(issueId)}] ` : "";
+				return `${i + 1}. ☐ ${idLabel}${t.text}`;
+			}).join("\n");
+			
+			const epicLabel = epicId ? `\n\nEpic: ${getShortId(epicId)}` : "";
+			pi.sendMessage(
+				{
+					customType: "plan-todo-list",
+					content: `**Plan Steps (${todoItems.length}):**${epicLabel}\n\n${todoListText}`,
+					display: true,
+				},
+				{ triggerTurn: false },
+			);
+		}
+
+		// Show "Start implementation?" prompt (no approval dialog for issue creation)
+		const choice = await ctx.ui.select("Start implementation?", [
+			todoItems.length > 0 ? "Yes, start with first step" : "Yes",
+			"Stay in plan mode",
+			"Refine the plan",
+		]);
+
+		if (choice?.startsWith("Yes")) {
+			// Auto-exit plan mode and start execution
+			planModeEnabled = false;
+			executionMode = todoItems.length > 0;
+			pi.setActiveTools(NORMAL_MODE_TOOLS);
+			updateStatus(ctx);
+
+			// Auto-claim first issue if available
+			if (todoItems.length > 0 && issueIds.size > 0) {
+				const firstIssueId = issueIds.get(todoItems[0].step);
+				if (firstIssueId) {
+					await bdClaim(firstIssueId, cwd);
+				}
+			}
+
+			const execMessage =
+				todoItems.length > 0
+					? `Execute the plan. Start with: ${todoItems[0].text}`
+					: "Execute the plan you just created.";
+			pi.sendMessage(
+				{ customType: "plan-mode-execute", content: execMessage, display: true },
+				{ triggerTurn: true },
+			);
+		} else if (choice === "Refine the plan") {
+			const refinement = await ctx.ui.editor("Refine the plan:", "");
+			if (refinement?.trim()) {
+				pi.sendUserMessage(refinement.trim());
+			}
+		}
+	});
+
+	// Restore state on session start/resume
+	pi.on("session_start", async (_event, ctx) => {
+		if (pi.getFlag("plan") === true) {
+			planModeEnabled = true;
+		}
+
+		const entries = ctx.sessionManager.getEntries();
+
+		// Restore persisted state
+		const planModeEntry = entries
+			.filter((e: { type: string; customType?: string }) => e.type === "custom" && e.customType === "plan-mode")
+			.pop() as { data?: { enabled: boolean; todos?: TodoItem[]; executing?: boolean; epicId?: string; issueIds?: Record<number, string> } } | undefined;
+
+		if (planModeEntry?.data) {
+			planModeEnabled = planModeEntry.data.enabled ?? planModeEnabled;
+			todoItems = planModeEntry.data.todos ?? todoItems;
+			executionMode = planModeEntry.data.executing ?? executionMode;
+			epicId = planModeEntry.data.epicId ?? null;
+			if (planModeEntry.data.issueIds) {
+				issueIds = new Map(Object.entries(planModeEntry.data.issueIds).map(([k, v]) => [Number(k), v]));
+			}
+		}
+
+		// On resume: re-scan messages to rebuild completion state
+		// Only scan messages AFTER the last "plan-mode-execute" to avoid picking up [DONE:n] from previous plans
+		const isResume = planModeEntry !== undefined;
+		if (isResume && executionMode && todoItems.length > 0) {
+			// Find the index of the last plan-mode-execute entry (marks when current execution started)
+			let executeIndex = -1;
+			for (let i = entries.length - 1; i >= 0; i--) {
+				const entry = entries[i] as { type: string; customType?: string };
+				if (entry.customType === "plan-mode-execute") {
+					executeIndex = i;
+					break;
+				}
+			}
+
+			// Only scan messages after the execute marker
+			const messages: AssistantMessage[] = [];
+			for (let i = executeIndex + 1; i < entries.length; i++) {
+				const entry = entries[i];
+				if (entry.type === "message" && "message" in entry && isAssistantMessage(entry.message as AgentMessage)) {
+					messages.push(entry.message as AssistantMessage);
+				}
+			}
+			const allText = messages.map(getTextContent).join("\n");
+			markCompletedSteps(allText, todoItems);
+		}
+
+		if (planModeEnabled) {
+			pi.setActiveTools(PLAN_MODE_TOOLS);
+		}
+		updateStatus(ctx);
+	});
+}