@oh-my-pi/pi-coding-agent 4.3.2 → 4.4.5

package/src/discovery/helpers.ts

@@ -5,11 +5,10 @@
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import { parse as parseYAML } from "yaml";
 import { readDirEntries, readFile } from "../capability/fs";
 import type { Skill, SkillFrontmatter } from "../capability/skill";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
-import { logger } from "../core/logger";
+import { parseFrontmatter } from "../core/frontmatter";
 
 const VALID_THINKING_LEVELS: readonly string[] = ["off", "minimal", "low", "medium", "high", "xhigh"];
 const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
@@ -120,42 +119,6 @@ export function createSourceMeta(provider: string, path: string, level: "user" |
 	};
 }
 
-/**
- * Strip YAML frontmatter from content.
- * Returns { frontmatter, body, raw }
- */
-export function parseFrontmatter(content: string): {
-	frontmatter: Record<string, unknown>;
-	body: string;
-	raw: string;
-} {
-	const normalized = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-
-	if (!normalized.startsWith("---")) {
-		return { frontmatter: {}, body: normalized, raw: "" };
-	}
-
-	const endIndex = normalized.indexOf("\n---", 3);
-	if (endIndex === -1) {
-		return { frontmatter: {}, body: normalized, raw: "" };
-	}
-
-	const raw = normalized.slice(4, endIndex);
-	const body = normalized.slice(endIndex + 4).trim();
-
-	try {
-		// Replace tabs with spaces for YAML compatibility, use failsafe mode for robustness
-		const frontmatter = parseYAML(raw.replaceAll("\t", "  "), { compat: "failsafe" }) as Record<
-			string,
-			unknown
-		> | null;
-		return { frontmatter: frontmatter ?? {}, body, raw };
-	} catch (error) {
-		logger.warn("Failed to parse YAML frontmatter", { error: String(error) });
-		return { frontmatter: {}, body, raw };
-	}
-}
-
 /**
  * Parse thinking level from frontmatter.
  * Supports keys: thinkingLevel, thinking-level, thinking
@@ -272,7 +235,7 @@ export async function loadSkillsFromDir(
 				return { item: null as Skill | null, warning: null as string | null };
 			}
 
-			const { frontmatter, body } = parseFrontmatter(content);
+			const { frontmatter, body } = parseFrontmatter(content, { source: skillFile });
 			if (requireDescription && !frontmatter.description) {
 				return { item: null as Skill | null, warning: null as string | null };
 			}

package/src/discovery/windsurf.ts

@@ -16,13 +16,13 @@ import { registerProvider } from "../capability/index";
 import { type MCPServer, mcpCapability } from "../capability/mcp";
 import { type Rule, ruleCapability } from "../capability/rule";
 import type { LoadContext, LoadResult } from "../capability/types";
+import { parseFrontmatter } from "../core/frontmatter";
 import {
 	createSourceMeta,
 	expandEnvVarsDeep,
 	getProjectPath,
 	getUserPath,
 	loadFilesFromDir,
-	parseFrontmatter,
 	parseJSON,
 } from "./helpers";
 
@@ -105,7 +105,7 @@ async function loadRules(ctx: LoadContext): Promise<LoadResult<Rule>> {
 	if (userPath) {
 		const content = await readFile(userPath);
 		if (content) {
-			const { frontmatter, body } = parseFrontmatter(content);
+			const { frontmatter, body } = parseFrontmatter(content, { source: userPath });
 
 			// Validate and normalize globs
 			let globs: string[] | undefined;
@@ -134,7 +134,7 @@ async function loadRules(ctx: LoadContext): Promise<LoadResult<Rule>> {
 		const result = await loadFilesFromDir<Rule>(ctx, projectRulesDir, PROVIDER_ID, "project", {
 			extensions: ["md"],
 			transform: (name, content, path, source) => {
-				const { frontmatter, body } = parseFrontmatter(content);
+				const { frontmatter, body } = parseFrontmatter(content, { source: path });
 				const ruleName = name.replace(/\.md$/, "");
 
 				// Validate and normalize globs

package/src/modes/interactive/components/custom-editor.ts

@@ -9,7 +9,6 @@ import {
 	isCtrlP,
 	isCtrlT,
 	isCtrlV,
-	isCtrlY,
 	isCtrlZ,
 	isEscape,
 	isShiftCtrlP,
@@ -36,7 +35,7 @@ export class CustomEditor extends Editor {
 	public onCtrlZ?: () => void;
 	public onQuestionMark?: () => void;
 	public onCapsLock?: () => void;
-	public onCtrlY?: () => void;
+	public onAltP?: () => void;
 	/** Called when Ctrl+V is pressed. Returns true if handled (image found), false to fall through to text paste. */
 	public onCtrlV?: () => Promise<boolean>;
 	/** Called when Alt+Up is pressed (dequeue keybinding). */
@@ -84,9 +83,9 @@ export class CustomEditor extends Editor {
 			return;
 		}
 
-		// Intercept Ctrl+Y for voice input
-		if (isCtrlY(data) && this.onCtrlY) {
-			this.onCtrlY();
+		// Intercept Alt+P for quick model switching
+		if (matchesKey(data, "alt+p") && this.onAltP) {
+			this.onAltP();
 			return;
 		}
 
@@ -102,12 +101,6 @@ export class CustomEditor extends Editor {
 			return;
 		}
 
-		// Intercept Ctrl+Y for role-based model cycling
-		if (isCtrlY(data) && this.onCtrlY) {
-			this.onCtrlY();
-			return;
-		}
-
 		// Intercept Ctrl+L for model selector
 		if (isCtrlL(data) && this.onCtrlL) {
 			this.onCtrlL();

package/src/modes/interactive/components/index.ts

@@ -19,6 +19,7 @@ export { LoginDialogComponent } from "./login-dialog";
 export { ModelSelectorComponent } from "./model-selector";
 export { OAuthSelectorComponent } from "./oauth-selector";
 export { QueueModeSelectorComponent } from "./queue-mode-selector";
+export { ReadToolGroupComponent } from "./read-tool-group";
 export { SessionSelectorComponent } from "./session-selector";
 export {
 	type SettingChangeHandler,
@@ -30,7 +31,7 @@ export { ShowImagesSelectorComponent } from "./show-images-selector";
 export { StatusLineComponent } from "./status-line";
 export { ThemeSelectorComponent } from "./theme-selector";
 export { ThinkingSelectorComponent } from "./thinking-selector";
-export { ToolExecutionComponent, type ToolExecutionOptions } from "./tool-execution";
+export { ToolExecutionComponent, type ToolExecutionHandle, type ToolExecutionOptions } from "./tool-execution";
 export { TreeSelectorComponent } from "./tree-selector";
 export { TtsrNotificationComponent } from "./ttsr-notification";
 export { UserMessageComponent } from "./user-message";

package/src/modes/interactive/components/read-tool-group.ts

@@ -0,0 +1,118 @@
+import type { Component } from "@oh-my-pi/pi-tui";
+import { Container, Text } from "@oh-my-pi/pi-tui";
+import { shortenPath } from "../../../core/tools/render-utils";
+import { theme } from "../theme/theme";
+import type { ToolExecutionHandle } from "./tool-execution";
+
+type ReadRenderArgs = {
+	path?: string;
+	file_path?: string;
+	offset?: number;
+	limit?: number;
+};
+
+type ReadEntry = {
+	toolCallId: string;
+	path: string;
+	offset?: number;
+	limit?: number;
+	status: "pending" | "success" | "error";
+};
+
+export class ReadToolGroupComponent extends Container implements ToolExecutionHandle {
+	private entries = new Map<string, ReadEntry>();
+	private text: Text;
+
+	constructor() {
+		super();
+		this.text = new Text("", 0, 0);
+		this.addChild(this.text);
+		this.updateDisplay();
+	}
+
+	updateArgs(args: ReadRenderArgs, toolCallId?: string): void {
+		if (!toolCallId) return;
+		const rawPath = args.file_path || args.path || "";
+		const entry: ReadEntry = this.entries.get(toolCallId) ?? {
+			toolCallId,
+			path: rawPath,
+			offset: args.offset,
+			limit: args.limit,
+			status: "pending",
+		};
+		entry.path = rawPath;
+		entry.offset = args.offset;
+		entry.limit = args.limit;
+		this.entries.set(toolCallId, entry);
+		this.updateDisplay();
+	}
+
+	updateResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: unknown; isError?: boolean },
+		isPartial = false,
+		toolCallId?: string,
+	): void {
+		if (!toolCallId) return;
+		const entry = this.entries.get(toolCallId);
+		if (!entry) return;
+		if (isPartial) return;
+		entry.status = result.isError ? "error" : "success";
+		this.updateDisplay();
+	}
+
+	setArgsComplete(_toolCallId?: string): void {
+		this.updateDisplay();
+	}
+
+	setExpanded(_expanded: boolean): void {
+		this.updateDisplay();
+	}
+
+	getComponent(): Component {
+		return this;
+	}
+
+	private updateDisplay(): void {
+		const entries = [...this.entries.values()];
+		const header = `${theme.fg("toolTitle", theme.bold("Read"))}${
+			entries.length > 1 ? theme.fg("dim", ` (${entries.length})`) : ""
+		}`;
+
+		if (entries.length === 0) {
+			this.text.setText(` ${theme.format.bullet} ${header}`);
+			return;
+		}
+
+		const lines = [` ${theme.format.bullet} ${header}`];
+		const total = entries.length;
+		for (const [index, entry] of entries.entries()) {
+			const connector = index === total - 1 ? theme.tree.last : theme.tree.branch;
+			const statusSymbol = this.formatStatus(entry.status);
+			const pathDisplay = this.formatPath(entry);
+			lines.push(`   ${theme.fg("dim", connector)} ${statusSymbol} ${pathDisplay}`.trimEnd());
+		}
+
+		this.text.setText(lines.join("\n"));
+	}
+
+	private formatPath(entry: ReadEntry): string {
+		const filePath = shortenPath(entry.path);
+		let pathDisplay = filePath ? theme.fg("accent", filePath) : theme.fg("toolOutput", theme.format.ellipsis);
+		if (entry.offset !== undefined || entry.limit !== undefined) {
+			const startLine = entry.offset ?? 1;
+			const endLine = entry.limit !== undefined ? startLine + entry.limit - 1 : "";
+			pathDisplay += theme.fg("warning", `:${startLine}${endLine ? `-${endLine}` : ""}`);
+		}
+		return pathDisplay;
+	}
+
+	private formatStatus(status: ReadEntry["status"]): string {
+		if (status === "success") {
+			return theme.fg("success", theme.status.success);
+		}
+		if (status === "error") {
+			return theme.fg("error", theme.status.error);
+		}
+		return theme.fg("dim", theme.status.pending);
+	}
+}

package/src/modes/interactive/components/todo-display.ts

@@ -0,0 +1,112 @@
+import * as path from "node:path";
+import { Text } from "@oh-my-pi/pi-tui";
+import { logger } from "../../../core/logger";
+import { getArtifactsDir } from "../../../core/tools/task/artifacts";
+import { theme } from "../theme/theme";
+import type { TodoItem } from "../types";
+
+const TODO_FILE_NAME = "todos.json";
+
+interface TodoFile {
+	updatedAt: number;
+	todos: TodoItem[];
+}
+
+async function loadTodoFile(filePath: string): Promise<TodoFile | null> {
+	const file = Bun.file(filePath);
+	if (!(await file.exists())) return null;
+	try {
+		const text = await file.text();
+		const data = JSON.parse(text) as TodoFile;
+		if (!data || !Array.isArray(data.todos)) return null;
+		return data;
+	} catch (error) {
+		logger.warn("Failed to read todo file", { path: filePath, error: String(error) });
+		return null;
+	}
+}
+
+export class TodoDisplayComponent {
+	public todos: TodoItem[] = [];
+	private expanded = false;
+	private visible = false;
+
+	constructor(private readonly sessionFile: string | null) {}
+
+	async loadTodos(): Promise<void> {
+		if (!this.sessionFile) {
+			this.todos = [];
+			this.visible = false;
+			return;
+		}
+
+		const artifactsDir = getArtifactsDir(this.sessionFile);
+		if (!artifactsDir) {
+			this.todos = [];
+			this.visible = false;
+			return;
+		}
+
+		const todoPath = path.join(artifactsDir, TODO_FILE_NAME);
+		const data = await loadTodoFile(todoPath);
+		this.todos = data?.todos ?? [];
+		this.visible = this.todos.length > 0;
+	}
+
+	setTodos(todos: TodoItem[]): void {
+		this.todos = todos;
+		this.visible = this.todos.length > 0;
+	}
+
+	setExpanded(expanded: boolean): void {
+		this.expanded = expanded;
+	}
+
+	isVisible(): boolean {
+		return this.visible;
+	}
+
+	render(_width: number): string[] {
+		if (!this.visible || this.todos.length === 0) {
+			return [];
+		}
+
+		const lines: string[] = [];
+		const maxItems = this.expanded ? this.todos.length : Math.min(5, this.todos.length);
+		const hasMore = !this.expanded && this.todos.length > 5;
+
+		for (let i = 0; i < maxItems; i++) {
+			const todo = this.todos[i];
+			const prefix = i === 0 ? `  ${theme.tree.hook} ` : "    ";
+
+			let checkbox: string;
+			let text: string;
+
+			if (todo.status === "completed") {
+				checkbox = theme.checkbox.checked;
+				text = theme.fg("success", `${prefix}${checkbox} ${theme.strikethrough(todo.content)}`);
+			} else if (todo.status === "in_progress") {
+				checkbox = theme.checkbox.unchecked;
+				const displayText = todo.activeForm !== todo.content ? todo.activeForm : todo.content;
+				text = theme.fg("accent", `${prefix}${checkbox} ${displayText}`);
+			} else {
+				checkbox = theme.checkbox.unchecked;
+				text = theme.fg("dim", `${prefix}${checkbox} ${todo.content}`);
+			}
+
+			lines.push(text);
+		}
+
+		if (hasMore) {
+			lines.push(theme.fg("dim", `      ${theme.tree.hook} +${this.todos.length - 5} more (Ctrl+T to expand)`));
+		}
+
+		return lines;
+	}
+
+	getRenderedComponent(): Text | null {
+		if (!this.visible) return null;
+		const lines = this.render(80);
+		return new Text(lines.join("\n"), 0, 0);
+	}
+}

package/src/modes/interactive/components/tool-execution.ts

@@ -86,6 +86,21 @@ export interface ToolExecutionOptions {
 	showImages?: boolean; // default: true (only used if terminal supports images)
 }
 
+export interface ToolExecutionHandle {
+	updateArgs(args: any, toolCallId?: string): void;
+	updateResult(
+		result: {
+			content: Array<{ type: string; text?: string; data?: string; mimeType?: string }>;
+			details?: any;
+			isError?: boolean;
+		},
+		isPartial?: boolean,
+		toolCallId?: string,
+	): void;
+	setArgsComplete(toolCallId?: string): void;
+	setExpanded(expanded: boolean): void;
+}
+
 /**
  * Component that renders a tool call with its result (updateable)
  */
@@ -152,7 +167,7 @@ export class ToolExecutionComponent extends Container {
 		this.updateDisplay();
 	}
 
-	updateArgs(args: any): void {
+	updateArgs(args: any, _toolCallId?: string): void {
 		this.args = args;
 		this.updateDisplay();
 	}
@@ -161,7 +176,7 @@ export class ToolExecutionComponent extends Container {
 	 * Signal that args are complete (tool is about to execute).
 	 * This triggers diff computation for edit tool.
 	 */
-	setArgsComplete(): void {
+	setArgsComplete(_toolCallId?: string): void {
 		this.maybeComputeEditDiff();
 	}
 
@@ -206,6 +221,7 @@ export class ToolExecutionComponent extends Container {
 			isError?: boolean;
 		},
 		isPartial = false,
+		_toolCallId?: string,
 	): void {
 		this.result = result;
 		this.isPartial = isPartial;

package/src/modes/interactive/controllers/command-controller.ts

@@ -334,11 +334,11 @@ export class CommandController {
 | \`Shift+Tab\` | Cycle thinking level |
 | \`Ctrl+P\` | Cycle role models (slow/default/smol) |
 | \`Shift+Ctrl+P\` | Cycle role models (temporary) |
-| \`Ctrl+Y\` | Select model (temporary) |
+| \`Alt+P\` | Select model (temporary) |
 | \`Ctrl+L\` | Select model (set roles) |
 | \`Ctrl+R\` | Search prompt history |
 | \`Ctrl+O\` | Toggle tool output expansion |
-| \`Ctrl+T\` | Toggle thinking block visibility |
+| \`Ctrl+T\` | Toggle todo list expansion |
 | \`Ctrl+G\` | Edit message in external editor |
 | \`/\` | Slash commands |
 | \`!\` | Run bash command |

package/src/modes/interactive/controllers/event-controller.ts

@@ -2,14 +2,33 @@ import { Loader, Text } from "@oh-my-pi/pi-tui";
 import type { AgentSessionEvent } from "../../../core/agent-session";
 import { detectNotificationProtocol, isNotificationSuppressed, sendNotification } from "../../../core/terminal-notify";
 import { AssistantMessageComponent } from "../components/assistant-message";
+import { ReadToolGroupComponent } from "../components/read-tool-group";
 import { ToolExecutionComponent } from "../components/tool-execution";
 import { TtsrNotificationComponent } from "../components/ttsr-notification";
 import { getSymbolTheme, theme } from "../theme/theme";
-import type { InteractiveModeContext } from "../types";
+import type { InteractiveModeContext, TodoItem } from "../types";
 
 export class EventController {
+	private lastReadGroup: ReadToolGroupComponent | undefined = undefined;
+	private lastThinkingCount = 0;
+
 	constructor(private ctx: InteractiveModeContext) {}
 
+	private resetReadGroup(): void {
+		this.lastReadGroup = undefined;
+	}
+
+	private getReadGroup(): ReadToolGroupComponent {
+		if (!this.lastReadGroup) {
+			this.ctx.chatContainer.addChild(new Text("", 0, 0));
+			const group = new ReadToolGroupComponent();
+			group.setExpanded(this.ctx.toolOutputExpanded);
+			this.ctx.chatContainer.addChild(group);
+			this.lastReadGroup = group;
+		}
+		return this.lastReadGroup;
+	}
+
 	subscribeToAgent(): void {
 		this.ctx.unsubscribe = this.ctx.session.subscribe(async (event: AgentSessionEvent) => {
 			await this.handleEvent(event);
@@ -53,17 +72,21 @@ export class EventController {
 
 			case "message_start":
 				if (event.message.role === "hookMessage" || event.message.role === "custom") {
+					this.resetReadGroup();
 					this.ctx.addMessageToChat(event.message);
 					this.ctx.ui.requestRender();
 				} else if (event.message.role === "user") {
+					this.resetReadGroup();
 					this.ctx.addMessageToChat(event.message);
 					this.ctx.editor.setText("");
 					this.ctx.updatePendingMessagesDisplay();
 					this.ctx.ui.requestRender();
 				} else if (event.message.role === "fileMention") {
+					this.resetReadGroup();
 					this.ctx.addMessageToChat(event.message);
 					this.ctx.ui.requestRender();
 				} else if (event.message.role === "assistant") {
+					this.lastThinkingCount = 0;
 					this.ctx.streamingComponent = new AssistantMessageComponent(undefined, this.ctx.hideThinkingBlock);
 					this.ctx.streamingMessage = event.message;
 					this.ctx.chatContainer.addChild(this.ctx.streamingComponent);
@@ -77,29 +100,45 @@ export class EventController {
 					this.ctx.streamingMessage = event.message;
 					this.ctx.streamingComponent.updateContent(this.ctx.streamingMessage);
 
+					const thinkingCount = this.ctx.streamingMessage.content.filter(
+						(content) => content.type === "thinking" && content.thinking.trim(),
+					).length;
+					if (thinkingCount > this.lastThinkingCount) {
+						this.resetReadGroup();
+						this.lastThinkingCount = thinkingCount;
+					}
+
 					for (const content of this.ctx.streamingMessage.content) {
-						if (content.type === "toolCall") {
-							if (!this.ctx.pendingTools.has(content.id)) {
-								this.ctx.chatContainer.addChild(new Text("", 0, 0));
-								const tool = this.ctx.session.getToolByName(content.name);
-								const component = new ToolExecutionComponent(
-									content.name,
-									content.arguments,
-									{
-										showImages: this.ctx.settingsManager.getShowImages(),
-									},
-									tool,
-									this.ctx.ui,
-									this.ctx.sessionManager.getCwd(),
-								);
-								component.setExpanded(this.ctx.toolOutputExpanded);
-								this.ctx.chatContainer.addChild(component);
-								this.ctx.pendingTools.set(content.id, component);
-							} else {
-								const component = this.ctx.pendingTools.get(content.id);
-								if (component) {
-									component.updateArgs(content.arguments);
-								}
+						if (content.type !== "toolCall") continue;
+
+						if (!this.ctx.pendingTools.has(content.id)) {
+							if (content.name === "read") {
+								const group = this.getReadGroup();
+								group.updateArgs(content.arguments, content.id);
+								this.ctx.pendingTools.set(content.id, group);
+								continue;
+							}
+
+							this.resetReadGroup();
+							this.ctx.chatContainer.addChild(new Text("", 0, 0));
+							const tool = this.ctx.session.getToolByName(content.name);
+							const component = new ToolExecutionComponent(
+								content.name,
+								content.arguments,
+								{
+									showImages: this.ctx.settingsManager.getShowImages(),
+								},
+								tool,
+								this.ctx.ui,
+								this.ctx.sessionManager.getCwd(),
+							);
+							component.setExpanded(this.ctx.toolOutputExpanded);
+							this.ctx.chatContainer.addChild(component);
+							this.ctx.pendingTools.set(content.id, component);
+						} else {
+							const component = this.ctx.pendingTools.get(content.id);
+							if (component) {
+								component.updateArgs(content.arguments, content.id);
 							}
 						}
 					}
@@ -133,17 +172,21 @@ export class EventController {
 							} else {
 								errorMessage = this.ctx.streamingMessage.errorMessage || "Error";
 							}
-							for (const [, component] of this.ctx.pendingTools.entries()) {
-								component.updateResult({
-									content: [{ type: "text", text: errorMessage }],
-									isError: true,
-								});
+							for (const [toolCallId, component] of this.ctx.pendingTools.entries()) {
+								component.updateResult(
+									{
+										content: [{ type: "text", text: errorMessage }],
+										isError: true,
+									},
+									false,
+									toolCallId,
+								);
 							}
 						}
 						this.ctx.pendingTools.clear();
 					} else {
-						for (const [, component] of this.ctx.pendingTools.entries()) {
-							component.setArgsComplete();
+						for (const [toolCallId, component] of this.ctx.pendingTools.entries()) {
+							component.setArgsComplete(toolCallId);
 						}
 					}
 					this.ctx.streamingComponent = undefined;
@@ -156,6 +199,15 @@ export class EventController {
 
 			case "tool_execution_start": {
 				if (!this.ctx.pendingTools.has(event.toolCallId)) {
+					if (event.toolName === "read") {
+						const group = this.getReadGroup();
+						group.updateArgs(event.args, event.toolCallId);
+						this.ctx.pendingTools.set(event.toolCallId, group);
+						this.ctx.ui.requestRender();
+						break;
+					}
+
+					this.resetReadGroup();
 					const tool = this.ctx.session.getToolByName(event.toolName);
 					const component = new ToolExecutionComponent(
 						event.toolName,
@@ -178,7 +230,7 @@ export class EventController {
 			case "tool_execution_update": {
 				const component = this.ctx.pendingTools.get(event.toolCallId);
 				if (component) {
-					component.updateResult({ ...event.partialResult, isError: false }, true);
+					component.updateResult({ ...event.partialResult, isError: false }, true, event.toolCallId);
 					this.ctx.ui.requestRender();
 				}
 				break;
@@ -187,10 +239,17 @@ export class EventController {
 			case "tool_execution_end": {
 				const component = this.ctx.pendingTools.get(event.toolCallId);
 				if (component) {
-					component.updateResult({ ...event.result, isError: event.isError });
+					component.updateResult({ ...event.result, isError: event.isError }, false, event.toolCallId);
 					this.ctx.pendingTools.delete(event.toolCallId);
 					this.ctx.ui.requestRender();
 				}
+				// Update todo display when todo_write tool completes
+				if (event.toolName === "todo_write" && !event.isError) {
+					const details = event.result.details as { todos?: TodoItem[] } | undefined;
+					if (details?.todos) {
+						this.ctx.setTodos(details.todos);
+					}
+				}
 				break;
 			}