pi-ui-extend 0.1.34 → 0.1.36

package/external/pi-tools-suite/src/glm-coding-discipline/index.ts

@@ -5,6 +5,7 @@ import type { Api, AssistantMessage, ImageContent, Model, TextContent } from "@e
 import { Type } from "typebox";
 
 import { loadPiToolsSuiteConfig } from "../config.js";
+import { ignoreStaleExtensionContextError } from "../context-usage.js";
 
 type ExtensionAPI = any;
 
@@ -189,20 +190,24 @@ export default function glmCodingDiscipline(pi: ExtensionAPI) {
 	}
 
 	function syncLookupToolAvailability(modelRef: string | undefined, cwd?: string): void {
-		const activeTools = typeof pi.getActiveTools === "function" ? pi.getActiveTools() : undefined;
-		if (!Array.isArray(activeTools)) return;
+		try {
+			const activeTools = typeof pi.getActiveTools === "function" ? pi.getActiveTools() : undefined;
+			if (!Array.isArray(activeTools)) return;
 
-		const lookupEnabled = Boolean(lookupModelFromConfig(cwd));
-		const shouldExposeLookup = lookupEnabled && isGlmModel(modelRef);
-		const hasLookup = activeTools.includes(LOOKUP_TOOL_NAME);
+			const lookupEnabled = Boolean(lookupModelFromConfig(cwd));
+			const shouldExposeLookup = lookupEnabled && isGlmModel(modelRef);
+			const hasLookup = activeTools.includes(LOOKUP_TOOL_NAME);
 
-		if (shouldExposeLookup === hasLookup) return;
-		if (typeof pi.setActiveTools !== "function") return;
+			if (shouldExposeLookup === hasLookup) return;
+			if (typeof pi.setActiveTools !== "function") return;
 
-		const nextTools = shouldExposeLookup
-			? [...activeTools, LOOKUP_TOOL_NAME]
-			: activeTools.filter((tool: unknown) => tool !== LOOKUP_TOOL_NAME);
-		pi.setActiveTools([...new Set(nextTools)]);
+			const nextTools = shouldExposeLookup
+				? [...activeTools, LOOKUP_TOOL_NAME]
+				: activeTools.filter((tool: unknown) => tool !== LOOKUP_TOOL_NAME);
+			pi.setActiveTools([...new Set(nextTools)]);
+		} catch (error) {
+			ignoreStaleExtensionContextError(error);
+		}
 	}
 
 	maybeRegisterLookupTool(process.cwd());

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

@@ -40,6 +40,14 @@ const MANAGED_TOOLS = new Set([...CLAUDE_ALIAS_TOOLS, ...CODEX_ALIAS_TOOLS, ...B
 const REPO_DISCOVERY_TOOL_NAME_SET = new Set(REPO_DISCOVERY_TOOL_NAMES);
 const MAX_BUILTIN_DEFINITIONS = 64;
 
+function isStaleExtensionContextError(error: unknown): boolean {
+	return error instanceof Error && /ctx is stale|stale ctx|stale after session replacement|stale after.*reload/i.test(error.message);
+}
+
+function ignoreStaleExtensionContextError(error: unknown): void {
+	if (!isStaleExtensionContextError(error)) throw error;
+}
+
 type ShellAliasInput = {
   command?: string;
   description?: string;
@@ -391,18 +399,22 @@ function sameTools(left: string[], right: string[]): boolean {
 }
 
 function applyToolProfile(pi: ExtensionAPI, model: unknown, baseTools: string[]): void {
-	const targetTools = toolsForProfile(detectModelProfile(model));
-	const preserveSelection = shouldPreserveSelection();
-	const active = pi.getActiveTools();
-	const repoTools = activeRepoDiscoveryTools(active, baseTools);
-	const preserved = active.filter((tool) => !MANAGED_TOOLS.has(tool) && !REPO_DISCOVERY_TOOL_NAME_SET.has(tool));
-	const baseWithoutRepoTools = baseTools.filter((tool) => !REPO_DISCOVERY_TOOL_NAME_SET.has(tool));
-	const selectedTargetTools = preserveSelection
-		? selectSuitableToolsForModel(model, active.filter((tool) => MANAGED_TOOLS.has(tool)))
-		: targetTools;
-	const next = selectedTargetTools ? [...repoTools, ...preserved, ...selectedTargetTools] : [...repoTools, ...preserved, ...baseWithoutRepoTools];
-	const nextTools = [...new Set(next)];
-	if (!sameTools(active, nextTools)) pi.setActiveTools(nextTools);
+	try {
+		const targetTools = toolsForProfile(detectModelProfile(model));
+		const preserveSelection = shouldPreserveSelection();
+		const active = pi.getActiveTools();
+		const repoTools = activeRepoDiscoveryTools(active, baseTools);
+		const preserved = active.filter((tool) => !MANAGED_TOOLS.has(tool) && !REPO_DISCOVERY_TOOL_NAME_SET.has(tool));
+		const baseWithoutRepoTools = baseTools.filter((tool) => !REPO_DISCOVERY_TOOL_NAME_SET.has(tool));
+		const selectedTargetTools = preserveSelection
+			? selectSuitableToolsForModel(model, active.filter((tool) => MANAGED_TOOLS.has(tool)))
+			: targetTools;
+		const next = selectedTargetTools ? [...repoTools, ...preserved, ...selectedTargetTools] : [...repoTools, ...preserved, ...baseWithoutRepoTools];
+		const nextTools = [...new Set(next)];
+		if (!sameTools(active, nextTools)) pi.setActiveTools(nextTools);
+	} catch (error) {
+		ignoreStaleExtensionContextError(error);
+	}
 }
 
 function shouldPreserveSelection(env: NodeJS.ProcessEnv = process.env): boolean {

package/external/pi-tools-suite/src/prompt-commands/index.ts

@@ -3,6 +3,7 @@ import { dirname } from "node:path";
 import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { applyEdits, modify, parse as parseJsonc } from "jsonc-parser";
 import { ensurePiToolsSuiteUserConfig, getPiToolsSuiteUserConfigPath } from "../config";
+import { ignoreStaleExtensionContextError } from "../context-usage";
 import { publishStartupSection } from "../startup-section";
 
 type PromptCommand = {
@@ -166,12 +167,20 @@ async function runPromptCommand(pi: ExtensionAPI, ctx: ExtensionCommandContext,
 	if (!prompt) return notify(ctx, `/${name} has an empty prompt.`, "error");
 
 	await ctx.waitForIdle();
-	pi.sendUserMessage(prompt);
+	try {
+		pi.sendUserMessage(prompt);
+	} catch (error) {
+		ignoreStaleExtensionContextError(error);
+	}
 }
 
 async function reloadAfterConfigChange(ctx: ExtensionCommandContext, message: string): Promise<void> {
 	notify(ctx, `${message}\nReloading commands from ${getConfigPath()}…`);
-	await ctx.reload();
+	try {
+		await ctx.reload();
+	} catch (error) {
+		ignoreStaleExtensionContextError(error);
+	}
 }
 
 async function selectCommand(ctx: ExtensionContext, title: string, commands: Record<string, PromptCommand>): Promise<string | undefined> {

package/external/pi-tools-suite/src/telegram-mirror/index.ts

@@ -35,6 +35,7 @@
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { loadTelegramMirrorConfig } from "../config.js";
+import { ignoreStaleExtensionContextError, isAgentBusyRaceError } from "../context-usage.js";
 import { TelegramBot } from "./bot.js";
 import { captureAbortableContext, registerPixEventHandlers, type PixMirrorHooks, type RendererSink } from "./events.js";
 import { TurnRenderer, type RendererEvent } from "./renderer.js";
@@ -104,11 +105,32 @@ export default function telegramMirror(pi: ExtensionAPI): void {
 		console.error(`[telegram-mirror] ${message}`);
 	};
 
+	function staleSafe<T>(callback: () => T, fallback?: T): T | undefined {
+		try {
+			return callback();
+		} catch (error) {
+			ignoreStaleExtensionContextError(error);
+			return fallback;
+		}
+	}
+
+	function sendUserMessageSafely(text: string): void {
+		try {
+			pi.sendUserMessage(text);
+		} catch (error) {
+			if (isAgentBusyRaceError(error)) {
+				pi.sendUserMessage(text, { deliverAs: "followUp" });
+				return;
+			}
+			throw error;
+		}
+	}
+
 	// Dispatch the leader uses to execute commands on its own pi session.
-		const localDispatch: LocalDispatch = {
-			sendUserMessage(text) {
-				pi.sendUserMessage(text);
-			},
+	const localDispatch: LocalDispatch = {
+		sendUserMessage(text) {
+			staleSafe(() => sendUserMessageSafely(text));
+		},
 			currentDialog() {
 				return mirrorCtx?.currentDialog();
 			},
@@ -119,8 +141,12 @@ export default function telegramMirror(pi: ExtensionAPI): void {
 			mirrorCtx?.compact();
 		},
 		status() {
-			if (!mirrorCtx) return undefined;
-			return { idle: mirrorCtx.isIdle(), hasPending: mirrorCtx.hasPendingMessages() };
+			const ctx = mirrorCtx;
+			if (!ctx) return undefined;
+			return {
+				idle: staleSafe(() => ctx.isIdle(), true) ?? true,
+				hasPending: staleSafe(() => ctx.hasPendingMessages(), false) ?? false,
+			};
 		},
 	};
 
@@ -336,7 +362,7 @@ export default function telegramMirror(pi: ExtensionAPI): void {
 		try {
 			switch (command) {
 				case "sendUserMessage":
-					pi.sendUserMessage(((args as { text?: string } | undefined)?.text ?? ""));
+					sendUserMessageSafely(((args as { text?: string } | undefined)?.text ?? ""));
 					break;
 				case "abort":
 					mirrorCtx?.abort();
@@ -477,22 +503,30 @@ export default function telegramMirror(pi: ExtensionAPI): void {
 	function refreshCtx(ctx: ExtensionContext | undefined): void {
 		if (!ctx) return;
 		if (!mirrorCtx) {
-				mirrorCtx = makeCtx({
-					abort: () => ctx.abort(),
-					isIdle: () => ctx.isIdle(),
-					hasPendingMessages: () => ctx.hasPendingMessages(),
-					compact: () => ctx.compact(),
+			mirrorCtx = makeCtx({
+					abort: () => {
+						staleSafe(() => ctx.abort());
+					},
+					isIdle: () => staleSafe(() => ctx.isIdle(), true) ?? true,
+					hasPendingMessages: () => staleSafe(() => ctx.hasPendingMessages(), false) ?? false,
+					compact: () => {
+						staleSafe(() => ctx.compact());
+					},
 					currentDialog: () => currentDialogFromContext(ctx),
 				});
-				return;
-			}
-		const m = mirrorCtx as Mutable<MirrorContext>;
-		m.abort = () => ctx.abort();
-			m.isIdle = () => ctx.isIdle();
-			m.hasPendingMessages = () => ctx.hasPendingMessages();
-			m.compact = () => ctx.compact();
-			m.currentDialog = () => currentDialogFromContext(ctx);
+			return;
 		}
+		const m = mirrorCtx as Mutable<MirrorContext>;
+		m.abort = () => {
+			staleSafe(() => ctx.abort());
+		};
+		m.isIdle = () => staleSafe(() => ctx.isIdle(), true) ?? true;
+		m.hasPendingMessages = () => staleSafe(() => ctx.hasPendingMessages(), false) ?? false;
+		m.compact = () => {
+			staleSafe(() => ctx.compact());
+		};
+		m.currentDialog = () => currentDialogFromContext(ctx);
+	}
 
 	function refreshSelfInfo(ctx: ExtensionContext | undefined): void {
 		const snapshot = sessionSnapshot(ctx);
@@ -611,13 +645,18 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 
 function sessionSnapshot(ctx: ExtensionContext | undefined): SessionSnapshot | undefined {
 	if (!ctx) return undefined;
-	const manager = ctx.sessionManager;
-	return {
-		cwd: manager.getCwd?.() ?? ctx.cwd,
-		...(manager.getSessionId?.() ? { sessionId: manager.getSessionId() } : {}),
-		...(manager.getSessionFile?.() ? { sessionFile: manager.getSessionFile() } : {}),
-		...(manager.getSessionName?.() ? { sessionName: manager.getSessionName() } : {}),
-	};
+	try {
+		const manager = ctx.sessionManager;
+		return {
+			cwd: manager.getCwd?.() ?? ctx.cwd,
+			...(manager.getSessionId?.() ? { sessionId: manager.getSessionId() } : {}),
+			...(manager.getSessionFile?.() ? { sessionFile: manager.getSessionFile() } : {}),
+			...(manager.getSessionName?.() ? { sessionName: manager.getSessionName() } : {}),
+		};
+	} catch (error) {
+		ignoreStaleExtensionContextError(error);
+		return undefined;
+	}
 }
 
 function notify(ctx: { hasUI?: boolean; ui?: { notify?: (message: string, type?: "info" | "warning" | "error") => void } }, message: string, type: "info" | "warning" | "error" = "info"): void {

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

@@ -1,12 +1,13 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { loadPiToolsSuiteConfig } from "../config.js";
+import { isAgentBusyRaceError } from "../context-usage.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 { applyTaskMutation } from "./state/state-reducer.js";
 import { getState, replaceState } from "./state/store.js";
-import { DEFAULT_PROMPT_GUIDELINES, DEFAULT_PROMPT_SNIPPET, publishTodoState, registerTodosCommand, registerTodoTool } from "./todo.js";
+import { activateTodoStateScope, DEFAULT_PROMPT_GUIDELINES, DEFAULT_PROMPT_SNIPPET, publishTodoState, registerTodosCommand, registerTodoTool } from "./todo.js";
 import type { Task, TaskMutationParams } from "./tool/types.js";
 
 type AgentMessageLike = { role?: unknown; stopReason?: unknown; content?: unknown };
@@ -17,6 +18,11 @@ const TODO_NUDGE_IDLE_RETRY_DELAY_MS = 100;
 const TODO_NUDGE_MAX_IDLE_ATTEMPTS = 40;
 const ASK_USER_TOOL_NAMES = new Set(["ask_user", "ask_user_question", "question"]);
 const TODO_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as const;
+const TODO_THINKING_RESTORE_METADATA_KEY = "__piTodoRestoreThinking";
+
+function isStaleExtensionContextError(error: unknown): boolean {
+	return error instanceof Error && /ctx is stale|stale ctx|stale after session replacement|stale after.*reload/i.test(error.message);
+}
 
 type TodoThinkingLevel = (typeof TODO_THINKING_LEVELS)[number];
 type ModelLike = { reasoning?: boolean; thinkingLevelMap?: Partial<Record<TodoThinkingLevel, unknown | null>> };
@@ -108,7 +114,12 @@ function getPersistedPlanPrompt(path: string): string | undefined {
 
 function emitPersistedPlanPrompt(pi: ExtensionAPI, ctx: ExtensionContext, prompt: string): void {
 	if (ctx.hasUI) {
-		pi.sendUserMessage(prompt);
+		try {
+			pi.sendUserMessage(prompt);
+		} catch (error) {
+			if (isStaleExtensionContextError(error)) return;
+			throw error;
+		}
 		return;
 	}
 	console.log(prompt);
@@ -128,10 +139,21 @@ export default function (pi: ExtensionAPI) {
 		const thinkingPrompt = todoThinkingEnabled ? buildThinkingPromptParts(currentModel) : {};
 		registerTodoTool(pi, {
 			...thinkingPrompt,
+			prepareMutation: (state, _ctx, info) => {
+				if (!todoThinkingEnabled) return info.params;
+				if (info.action === "update") return prepareTodoThinkingMutation(state, info.params);
+				if (info.action === "batch_update") {
+					return {
+						...info.params,
+						items: (info.params.items ?? []).map((item) => prepareTodoThinkingMutation(state, item)),
+					};
+				}
+				return info.params;
+			},
 			afterCommit: async (state, ctx, info) => {
 				if (todoThinkingEnabled) applyTodoThinkingAfterCommit(state, info);
 				try {
-					const sync = syncPersistedPlan(ctx.cwd, state);
+					const sync = syncPersistedPlan(ctx.cwd, info.committedState);
 					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}`);
@@ -144,7 +166,7 @@ export default function (pi: ExtensionAPI) {
 		const mutations = getTodoThinkingMutations(info.action, info.params);
 		for (const mutation of mutations) {
 			if (mutation.id === undefined || mutation.status === "in_progress") continue;
-			restoreTaskThinking(mutation.id);
+			restoreTaskThinking(mutation.id, state);
 		}
 		restoreInactiveTodoThinking(state);
 		for (const mutation of mutations) {
@@ -167,6 +189,34 @@ export default function (pi: ExtensionAPI) {
 		return isTodoThinkingLevel(level) ? level : undefined;
 	}
 
+	function prepareTodoThinkingMutation(state: ReturnType<typeof getState>, params: TaskMutationParams): TaskMutationParams {
+		if (params.id === undefined) return params;
+		const current = state.tasks.find((task) => task.id === params.id);
+		if (!current) return params;
+		const nextStatus = params.status ?? current.status;
+		const nextThinking = params.thinking ?? current.thinking;
+		const shouldCapturePreviousThinking =
+			nextStatus === "in_progress" && nextThinking !== undefined && (current.status !== "in_progress" || params.thinking !== undefined);
+		if (!shouldCapturePreviousThinking) return params;
+		const currentThinking = getCurrentThinkingLevel();
+		if (!currentThinking) return params;
+		return {
+			...params,
+			metadata: {
+				...(params.metadata ?? {}),
+				[TODO_THINKING_RESTORE_METADATA_KEY]: currentThinking,
+			},
+		};
+	}
+
+	function getRememberedThinking(taskId: number, state: ReturnType<typeof getState>): TodoThinkingLevel | undefined {
+		const remembered = rememberedThinkingByTaskId.get(taskId);
+		if (remembered) return remembered;
+		const task = state.tasks.find((item) => item.id === taskId);
+		const stored = task?.metadata?.[TODO_THINKING_RESTORE_METADATA_KEY];
+		return isTodoThinkingLevel(stored) ? stored : undefined;
+	}
+
 	function switchToTaskThinking(taskId: number, level: TodoThinkingLevel): void {
 		if (!getAvailableTodoThinkingLevels(currentModel).includes(level)) return;
 		const current = getCurrentThinkingLevel();
@@ -175,8 +225,8 @@ export default function (pi: ExtensionAPI) {
 		if (current !== level) setTodoThinkingLevel(level);
 	}
 
-	function restoreTaskThinking(taskId: number): void {
-		const previous = rememberedThinkingByTaskId.get(taskId);
+	function restoreTaskThinking(taskId: number, state: ReturnType<typeof getState>): void {
+		const previous = getRememberedThinking(taskId, state);
 		if (!previous) return;
 		rememberedThinkingByTaskId.delete(taskId);
 		if (getCurrentThinkingLevel() !== previous) setTodoThinkingLevel(previous);
@@ -186,7 +236,7 @@ export default function (pi: ExtensionAPI) {
 		for (const taskId of [...rememberedThinkingByTaskId.keys()]) {
 			const task = state.tasks.find((item) => item.id === taskId);
 			if (task?.status === "in_progress") continue;
-			restoreTaskThinking(taskId);
+			restoreTaskThinking(taskId, state);
 		}
 	}
 
@@ -197,13 +247,20 @@ export default function (pi: ExtensionAPI) {
 		setter.call(pi, level);
 	}
 
-function isCompletedAssistantReply(message: AgentMessageLike | undefined): boolean {
-	if (message?.role !== "assistant") return false;
-	if (message.stopReason === "aborted" || message.stopReason === "error" || message.stopReason === "length") return false;
-	if (typeof message.content === "string") return message.content.trim().length > 0;
-	if (!Array.isArray(message.content)) return false;
-	return message.content.some((block) => typeof (block as { type?: unknown }).type === "string");
-}
+	function hasVisibleAssistantContent(content: unknown): boolean {
+		if (typeof content === "string") return content.trim().length > 0;
+		if (!Array.isArray(content)) return false;
+		return content.some((block) => {
+			const candidate = block as { type?: unknown; text?: unknown };
+			return candidate.type === "text" && typeof candidate.text === "string" && candidate.text.trim().length > 0;
+		});
+	}
+
+	function isCompletedAssistantReply(message: AgentMessageLike | undefined): boolean {
+		if (message?.role !== "assistant") return false;
+		if (message.stopReason === "aborted" || message.stopReason === "error" || message.stopReason === "length" || message.stopReason === "toolUse") return false;
+		return hasVisibleAssistantContent(message.content);
+	}
 
 	function hasCompletedAssistantReply(messages: readonly unknown[] | undefined): boolean {
 		if (!Array.isArray(messages)) return false;
@@ -227,6 +284,7 @@ function isCompletedAssistantReply(message: AgentMessageLike | undefined): boole
 	}
 
 	function applyInternalTodoMutation(action: "update", params: TaskMutationParams, ctx: ExtensionContext): boolean {
+		activateTodoStateScope(ctx);
 		const result = applyTaskMutation(getState(), action, params);
 		if (result.op.kind === "error") {
 			console.warn(`rpiv-todo: failed internal ${action} mutation — ${result.op.message}`);
@@ -235,7 +293,7 @@ function isCompletedAssistantReply(message: AgentMessageLike | undefined): boole
 		const autoClear = autoClearCompletedTodos(result.state);
 		replaceState(autoClear.state);
 		publishTodoState(pi as any, ctx, action, params as Record<string, unknown>);
-		if (todoThinkingEnabled) applyTodoThinkingAfterCommit(autoClear.state, { action, params });
+		if (todoThinkingEnabled) applyTodoThinkingAfterCommit(result.state, { action, params });
 		try {
 			const sync = syncPersistedPlan(ctx.cwd, autoClear.state);
 			if (sync?.completed) console.log(`rpiv-todo: completed persisted plan and removed ${sync.path}`);
@@ -246,6 +304,7 @@ function isCompletedAssistantReply(message: AgentMessageLike | undefined): boole
 	}
 
 	function maybeRecoverCompletedCurrentTask(messages: readonly unknown[] | undefined, ctx: ExtensionContext): boolean {
+		activateTodoStateScope(ctx);
 		if (!hasCompletedAssistantReply(messages)) return false;
 		const task = findOptimisticallyCompletableTask(getState().tasks);
 		if (!task) return false;
@@ -264,6 +323,7 @@ function isCompletedAssistantReply(message: AgentMessageLike | undefined): boole
 		nudgeTimer = setTimeout(() => {
 			nudgeTimer = undefined;
 			try {
+				activateTodoStateScope(ctx);
 				if (!ctx.isIdle()) {
 					if (attempt < TODO_NUDGE_MAX_IDLE_ATTEMPTS) scheduleTodoNudge(ctx, attempt + 1);
 					return;
@@ -286,6 +346,11 @@ function isCompletedAssistantReply(message: AgentMessageLike | undefined): boole
 				// queueing followUp from inside agent_end can be too late to be drained.
 				pi.sendUserMessage(nudge.message);
 			} catch (err) {
+				if (isAgentBusyRaceError(err)) {
+					if (attempt < TODO_NUDGE_MAX_IDLE_ATTEMPTS) scheduleTodoNudge(ctx, attempt + 1);
+					return;
+				}
+				if (isStaleExtensionContextError(err)) return;
 				console.warn(`rpiv-todo: failed to auto-nudge unfinished todos — ${(err as Error).message}`);
 			}
 		}, delayMs);
@@ -295,6 +360,7 @@ function isCompletedAssistantReply(message: AgentMessageLike | undefined): boole
 	registerTodosCommand(pi);
 
 	pi.on("session_start", async (_event, ctx) => {
+		activateTodoStateScope(ctx);
 		currentModel = ctx.model;
 		registerTodoToolWithCurrentPrompt();
 		const persisted = loadPersistedPlan(ctx.cwd);
@@ -313,12 +379,14 @@ function isCompletedAssistantReply(message: AgentMessageLike | undefined): boole
 	});
 
 	pi.on("session_compact", async (_event, ctx) => {
+		activateTodoStateScope(ctx);
 		replaceState(autoClearCompletedTodos(loadPersistedPlan(ctx.cwd)?.state ?? replayFromBranch(ctx)).state);
 		publishTodoState(pi as any, ctx);
 		lastNudgedSignature = undefined;
 	});
 
 	pi.on("session_tree", async (_event, ctx) => {
+		activateTodoStateScope(ctx);
 		replaceState(autoClearCompletedTodos(loadPersistedPlan(ctx.cwd)?.state ?? replayFromBranch(ctx)).state);
 		publishTodoState(pi as any, ctx);
 		lastNudgedSignature = undefined;
@@ -345,12 +413,14 @@ function isCompletedAssistantReply(message: AgentMessageLike | undefined): boole
 		if (isAskUserToolName(event.toolName)) pendingAskUserToolCallIds.delete(event.toolCallId);
 	});
 
-	pi.on("agent_start", async () => {
+	pi.on("agent_start", async (_event, ctx) => {
+		activateTodoStateScope(ctx);
 		pendingAskUserToolCallIds.clear();
 		inProgressAtAgentStart = new Set(selectVisibleTasks(getState()).filter((task) => task.status === "in_progress").map((task) => task.id));
 	});
 
 	pi.on("message_end", async (event, ctx) => {
+		activateTodoStateScope(ctx);
 		if (!isCompletedAssistantReply((event as { message?: AgentMessageLike } | undefined)?.message)) return;
 		if (maybeRecoverCompletedCurrentTask([(event as { message?: AgentMessageLike }).message], ctx)) {
 			lastNudgedSignature = undefined;
@@ -359,6 +429,7 @@ function isCompletedAssistantReply(message: AgentMessageLike | undefined): boole
 	});
 
 	pi.on("agent_end", async (event, ctx) => {
+		activateTodoStateScope(ctx);
 		const completedAssistantReply = hasCompletedAssistantReply((event as { messages?: readonly unknown[] } | undefined)?.messages);
 
 		if (suppressNextNudgeForThinkingSwitch) {

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

@@ -1,28 +1,57 @@
 import type { Task } from "../tool/types.js";
 import { EMPTY_STATE, type TaskState } from "./state.js";
 
+const DEFAULT_SCOPE_KEY = "__default__";
+
 /**
- * Module-level live state cell. Pre-refactor this lived as bare `tasks` /
- * `nextId` consts in `todo.ts`; centralizing here keeps the store as the
- * single mutation seam and lets the reducer remain pure.
+ * Module-level live state cells, keyed by the active Pi session identity.
+ * Pi can keep multiple SDK runtimes/tabs alive in one Node process, so a
+ * single module-level todo cell leaks tasks across sessions. Keep the legacy
+ * getState()/commitState() API, but make it resolve through the current scope.
  */
-let state: TaskState = { tasks: [...EMPTY_STATE.tasks], nextId: EMPTY_STATE.nextId };
+let activeScopeKey = DEFAULT_SCOPE_KEY;
+const statesByScopeKey = new Map<string, TaskState>([
+	[DEFAULT_SCOPE_KEY, { tasks: [...EMPTY_STATE.tasks], nextId: EMPTY_STATE.nextId }],
+]);
+
+function emptyState(): TaskState {
+	return { tasks: [...EMPTY_STATE.tasks], nextId: EMPTY_STATE.nextId };
+}
+
+function normalizedScopeKey(scopeKey: string | undefined): string {
+	const trimmed = scopeKey?.trim();
+	return trimmed ? trimmed : DEFAULT_SCOPE_KEY;
+}
+
+function activeState(): TaskState {
+	let state = statesByScopeKey.get(activeScopeKey);
+	if (!state) {
+		state = emptyState();
+		statesByScopeKey.set(activeScopeKey, state);
+	}
+	return state;
+}
+
+export function activateStateScope(scopeKey: string | undefined): void {
+	activeScopeKey = normalizedScopeKey(scopeKey);
+	activeState();
+}
 
 /**
  * Live tasks accessor. Returned `readonly Task[]` so callers cannot mutate the
  * live cell. Consumers must not cast back.
  */
 export function getTodos(): readonly Task[] {
-	return state.tasks;
+	return activeState().tasks;
 }
 
 export function getNextId(): number {
-	return state.nextId;
+	return activeState().nextId;
 }
 
 /** Snapshot accessor used by reducer callers to pass canonical state in. */
 export function getState(): TaskState {
-	return state;
+	return activeState();
 }
 
 /**
@@ -31,7 +60,7 @@ export function getState(): TaskState {
  * `replayFromBranch` decodes the latest snapshot.
  */
 export function replaceState(next: TaskState): void {
-	state = next;
+	statesByScopeKey.set(activeScopeKey, next);
 }
 
 /**
@@ -39,7 +68,7 @@ export function replaceState(next: TaskState): void {
  * `state` output to publish the new canonical state to live readers.
  */
 export function commitState(next: TaskState): void {
-	state = next;
+	statesByScopeKey.set(activeScopeKey, next);
 }
 
 /**
@@ -48,5 +77,7 @@ export function commitState(next: TaskState): void {
  * Plan §Decisions §Decision 7.
  */
 export function __resetState(): void {
-	state = { tasks: [...EMPTY_STATE.tasks], nextId: EMPTY_STATE.nextId };
+	activeScopeKey = DEFAULT_SCOPE_KEY;
+	statesByScopeKey.clear();
+	statesByScopeKey.set(DEFAULT_SCOPE_KEY, emptyState());
 }