pi-ui-extend 1.0.24 → 1.0.28

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

@@ -63,6 +63,7 @@ import {
 	collectProviderToolResultEvidence,
 	providerPayloadIncludesToolResult,
 } from "./provider-tool-results.js"
+import { reconcileInheritedCompressionBlocks } from "./pruner-compression-blocks.js"
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -232,6 +233,7 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 
 	// ── 2. Create state ───────────────────────────────────────────────────────
 	const state = createState()
+	let pendingInheritedBlockReconciliation = false
 	const pendingProviderToolIds = new Set<string>()
 	const appendNudgeTelemetry = (
 		event: "emitted" | "upgraded" | "reapplied",
@@ -275,6 +277,7 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 	pi.on("session_start", async (event, ctx) => {
 		// Reset to a clean slate first.
 		resetState(state)
+		pendingInheritedBlockReconciliation = false
 
 		// Reset dedup hash before loading the sidecar state for this session.
 		resetDcpPersistenceDedup()
@@ -290,6 +293,7 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 			// Cleanup is opportunistic; stale sidecars must not block session startup.
 		})
 		restoreState(state, await loadDcpState(ctx))
+		pendingInheritedBlockReconciliation = state.compressionBlocks.length > 0
 
 		// fork/resume/new sessions inherit the source conversation but get a fresh
 		// sidecar; inherit the previous session's compression blocks so they are
@@ -299,6 +303,7 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 				const inherited = await loadDcpStateFromSessionFile(event.previousSessionFile)
 				const added = inheritCompressionBlocks(state, inherited)
 				if (added > 0) {
+					pendingInheritedBlockReconciliation = true
 					writeDcpDebugLog(configForContext(ctx), "session_start.inherited_blocks", {
 						reason: event.reason,
 						previousSessionFile: event.previousSessionFile,
@@ -433,6 +438,22 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 			return { messages: contextMessages }
 		}
 		annotateMessagesWithBranchEntryIds(contextMessages, ctx)
+		if (pendingInheritedBlockReconciliation) {
+			pendingInheritedBlockReconciliation = false
+			const reconciliation = reconcileInheritedCompressionBlocks(contextMessages, state)
+			writeDcpDebugLog(
+				effectiveConfig,
+				"context.reconciled_inherited_blocks",
+				{ ...reconciliation },
+				ctx,
+			)
+			if (
+				reconciliation.activatedBlockIds.length > 0 ||
+				reconciliation.deactivatedBlockIds.length > 0
+			) {
+				await saveDcpState(ctx, state)
+			}
+		}
 		let prunedMessages = applyPruning(contextMessages, state, effectiveConfig)
 		let candidate = null as ReturnType<typeof detectCompressionCandidate>
 		let messageCandidates = [] as ReturnType<typeof detectMessageCompressionCandidates>

package/external/pi-tools-suite/src/dcp/pruner-compression-blocks.ts

@@ -13,6 +13,98 @@ function findBoundaryIndex(messages: any[], stableId: string | undefined, timest
   return messages.findIndex((m, index) => messageMatchesBoundary(m, index, stableId, timestamp));
 }
 
+export interface ReconcileInheritedBlocksResult {
+  fittingBlockIds: number[];
+  activatedBlockIds: number[];
+  deactivatedBlockIds: number[];
+}
+
+/**
+ * Reconcile inherited compression state with the branch that is actually
+ * being sent to the provider.
+ *
+ * A fork can branch before the source session's newest roll-up block ends.
+ * That roll-up remains active in the source sidecar, while the older block it
+ * covered is inactive. Since the roll-up's end boundary is absent on the
+ * fork, neither block would otherwise be applied and the whole history would
+ * be sent raw. Select the widest fitting block(s) instead, while preserving an
+ * explicit user decompression for the block and its covered descendants.
+ */
+export function reconcileInheritedCompressionBlocks(
+  messages: any[],
+  state: DcpState,
+): ReconcileInheritedBlocksResult {
+  const byId = new Map(state.compressionBlocks.map((block) => [block.id, block]));
+  const fittingBlockIds = new Set<number>();
+  const descendantCache = new Map<number, Set<number>>();
+
+  for (const block of state.compressionBlocks) {
+    if (!Number.isFinite(block.startTimestamp) || !Number.isFinite(block.endTimestamp)) continue;
+    const startFound = findBoundaryIndex(messages, block.startMessageId, block.startTimestamp) !== -1;
+    const endFound = findBoundaryIndex(messages, block.endMessageId, block.endTimestamp) !== -1;
+    if (startFound && endFound) fittingBlockIds.add(block.id);
+  }
+
+  function descendantsOf(rootId: number): Set<number> {
+    const cached = descendantCache.get(rootId);
+    if (cached) return cached;
+
+    const descendants = new Set<number>();
+    const pending = [...(byId.get(rootId)?.coveredBlockIds ?? [])];
+    while (pending.length > 0) {
+      const id = pending.pop()!;
+      if (id === rootId || descendants.has(id)) continue;
+      descendants.add(id);
+      pending.push(...(byId.get(id)?.coveredBlockIds ?? []));
+    }
+    descendantCache.set(rootId, descendants);
+    return descendants;
+  }
+
+  // Decompressing a roll-up intentionally exposes its whole range. Do not
+  // unexpectedly reactivate one of its older nested summaries after a fork.
+  const suppressedByUser = new Set<number>();
+  for (const block of state.compressionBlocks) {
+    if (!block.deactivatedByUser) continue;
+    suppressedByUser.add(block.id);
+    for (const id of descendantsOf(block.id)) suppressedByUser.add(id);
+  }
+
+  const eligibleBlockIds = new Set(
+    [...fittingBlockIds].filter((id) => !suppressedByUser.has(id)),
+  );
+  const coveredByFittingBlock = new Set<number>();
+  for (const id of eligibleBlockIds) {
+    for (const coveredId of descendantsOf(id)) coveredByFittingBlock.add(coveredId);
+  }
+
+  const activeBlockIds = new Set(
+    [...eligibleBlockIds].filter((id) => !coveredByFittingBlock.has(id)),
+  );
+  const activatedBlockIds: number[] = [];
+  const deactivatedBlockIds: number[] = [];
+
+  for (const block of state.compressionBlocks) {
+    const shouldBeActive = activeBlockIds.has(block.id);
+    if (block.active !== shouldBeActive) {
+      if (shouldBeActive) activatedBlockIds.push(block.id);
+      else deactivatedBlockIds.push(block.id);
+    }
+    block.active = shouldBeActive;
+
+    if (block.deactivatedByUser) continue;
+    block.deactivatedReason = fittingBlockIds.has(block.id)
+      ? undefined
+      : "outside-inherited-branch";
+  }
+
+  return {
+    fittingBlockIds: [...fittingBlockIds].sort((a, b) => a - b),
+    activatedBlockIds: activatedBlockIds.sort((a, b) => a - b),
+    deactivatedBlockIds: deactivatedBlockIds.sort((a, b) => a - b),
+  };
+}
+
 
 export function syncCompressionBlocks(messages: any[], state: DcpState, config: DcpConfig): void {
   if (state.compressionBlocks.length === 0) return;

package/external/pi-tools-suite/src/default-pi-tools-suite-config.ts

@@ -23,7 +23,7 @@ export const DEFAULT_PI_TOOLS_SUITE_CONFIG_JSONC = String.raw`{
   },
   // Vision-capable model used by the coding-discipline lookup tool for blind-model
   // screenshot/image questions. Remove or set to null to disable lookup.
-  "lookupModel": "openai-codex/gpt-5.4-mini",
+  "lookupModel": "openai-codex/gpt-5.6-luna",
   // coding-discipline working-state strictness.
   //   "lenient" (default): batch independent read-only tool calls; brief reasoning
   //     text is acceptable when thinking is off. Text only counts as chatter when a
@@ -148,7 +148,7 @@ export const DEFAULT_PI_TOOLS_SUITE_CONFIG_JSONC = String.raw`{
   },
   "asyncSubagents": {
     "defaultType": "quick",
-    "routing": { "enabled": true, "model": "zai/glm-4.5-air", "maxTaskChars": 1200, "maxTokens": 512, "maxRetries": 1, "timeoutMs": 12000, "debug": false },
+    "routing": { "enabled": true, "model": "zai/glm-4.5-air", "fallbackModels": ["openai-codex/gpt-5.6-luna"], "maxTaskChars": 1200, "maxTokens": 512, "maxRetries": 1, "timeoutMs": 12000, "debug": false },
     "presets": {
       "cheap": {
         "description": "Use cheap GLM/Gemini Flash models for text/code roles.",
@@ -222,33 +222,33 @@ export const DEFAULT_PI_TOOLS_SUITE_CONFIG_JSONC = String.raw`{
         "description": "Use only enabled strong models, mixing GPT, Claude, and Gemini by role.",
         "types": {
           "quick": {
-            "model": "openai-codex/gpt-5.4-mini",
+            "model": "openai-codex/gpt-5.6-luna",
             "fallbackModels": ["zai/glm-4.5-air"],
             "thinking": "low"
           },
           "scan": {
             "model": "antigravity/gemini-3-flash-preview",
-            "fallbackModels": ["openai-codex/gpt-5.3-codex-spark", "zai/glm-4.5-air"],
+            "fallbackModels": ["openai-codex/gpt-5.6-luna", "zai/glm-4.5-air"],
             "thinking": "off"
           },
           "research": {
             "model": "antigravity/gemini-3.1-pro-preview",
-            "fallbackModels": ["openai-codex/gpt-5.4-mini", "zai/glm-5-turbo"],
+            "fallbackModels": ["openai-codex/gpt-5.6-luna", "zai/glm-5-turbo"],
             "thinking": "medium"
           },
           "docs": {
             "model": "antigravity/gemini-2.5-flash",
-            "fallbackModels": ["openai-codex/gpt-5.3-codex-spark", "zai/glm-4.5-air"],
+            "fallbackModels": ["openai-codex/gpt-5.6-luna", "zai/glm-4.5-air"],
             "thinking": "medium"
           },
           "frontend": {
             "model": "antigravity/gemini-3.1-pro-preview-customtools",
-            "fallbackModels": ["zai/glm-5.3"],
+            "fallbackModels": ["openai-codex/gpt-5.6-luna", "zai/glm-5.3"],
             "thinking": "low"
           },
           "tests": {
             "model": "antigravity/antigravity-claude-sonnet-4-6",
-            "fallbackModels": ["openai-codex/gpt-5.4-mini", "zai/glm-5-turbo"],
+            "fallbackModels": ["openai-codex/gpt-5.6-luna", "zai/glm-5-turbo"],
             "thinking": "high"
           },
           "review": {
@@ -272,26 +272,29 @@ export const DEFAULT_PI_TOOLS_SUITE_CONFIG_JSONC = String.raw`{
     "types": {
       "quick": {
         "description": "Use for tiny cheap tasks: answer a simple question, inspect one known file, or verify one fact. Not for broad repo search.",
-        "model": "zai/glm-5-turbo",
+        "model": "openai-codex/gpt-5.6-luna",
+        "fallbackModels": ["zai/glm-4.5-air"],
         "thinking": "off"
       },
       "scan": {
         "description": "Use for finding files, symbols, text, or inventory across a repo. Return paths/facts; do not judge code quality.",
-        "model": "zai/glm-5-turbo",
+        "model": "openai-codex/gpt-5.6-luna",
+        "fallbackModels": ["zai/glm-4.5-air"],
         "thinking": "off",
         "tools": ["read", "grep"]
       },
       "research": {
         "description": "Use for multi-file codebase research: read several files and explain how something works. No edits.",
-        "model": "zai/glm-5-turbo",
+        "model": "openai-codex/gpt-5.6-terra",
+        "fallbackModels": ["zai/glm-5-turbo"],
         "thinking": "low",
         "tools": ["read", "grep"]
       },
-      "docs": { "description": "Use for documentation work: README/API docs review, docs gaps, changelog, migration notes, examples.", "model": "zai/glm-5-turbo", "thinking": "low" },
+      "docs": { "description": "Use for documentation work: README/API docs review, docs gaps, changelog, migration notes, examples.", "model": "openai-codex/gpt-5.6-luna", "fallbackModels": ["zai/glm-4.5-air"], "thinking": "low" },
       "frontend": {
         "description": "Use for frontend UI/UX visual work: styling, layout, typography, animation, responsive states, component polish, accessibility. Avoid backend/business logic unless needed for UI behavior.",
         "model": "antigravity/gemini-3-flash-preview",
-        "fallbackModels": ["openai-codex/gpt-5.4-mini", "zai/glm-5.3"],
+        "fallbackModels": ["openai-codex/gpt-5.6-luna", "zai/glm-5.3"],
         "thinking": "medium",
         "promptAppend": [
           "Act as a frontend UI/UX engineer for visual and product-facing work.",
@@ -302,14 +305,16 @@ export const DEFAULT_PI_TOOLS_SUITE_CONFIG_JSONC = String.raw`{
       },
       "browser-qa": {
         "description": "Use for browser-based visual QA: reproduce UI bugs and verify fixes with deterministic assertions, screenshots, video, and traces.",
-        "model": "openai-codex/gpt-5.4-mini",
+        "model": "openai-codex/gpt-5.6-luna",
         "fallbackModels": ["antigravity/gemini-3-flash-preview", "zai/glm-5.3"],
-        "thinking": "medium",
+        "thinking": "low",
+        "timeoutMs": 120000,
         "tools": ["read", "grep", "bash"]
       },
       "tests": {
         "description": "Use for tests: locate coverage, find gaps, run/check targeted test commands, diagnose failing tests.",
-        "model": "zai/glm-5-turbo",
+        "model": "openai-codex/gpt-5.6-terra",
+        "fallbackModels": ["zai/glm-5-turbo"],
         "thinking": "medium",
         "tools": ["read", "grep", "bash"]
       },

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

@@ -7,7 +7,15 @@ 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 { activateTodoStateScope, DEFAULT_PROMPT_GUIDELINES, DEFAULT_PROMPT_SNIPPET, publishTodoState, registerTodosCommand, registerTodoTool } from "./todo.js";
+import {
+	activateTodoStateScope,
+	DEFAULT_PROMPT_GUIDELINES,
+	DEFAULT_PROMPT_SNIPPET,
+	publishTodoState,
+	registerTodosCommand,
+	registerTodoTool,
+	todoStateScopeFromContext,
+} from "./todo.js";
 import {
 	TODO_THINKING_LEVEL_VALUES,
 	todoParamsSchemaForThinkingLevels,
@@ -216,7 +224,7 @@ export default function (pi: ExtensionAPI) {
 	const todoConfig = loadPiToolsSuiteConfig(["todo"]);
 	const todoThinkingEnabled = todoConfig.todoThinking;
 	const todoThinkingOverrides = todoConfig.todoThinkingOverrides;
-	const rememberedThinkingByTaskId = new Map<number, TodoThinkingLevel>();
+	const baselineThinkingByScope = new Map<string, TodoThinkingLevel>();
 	let lastNudgedSignature: string | undefined;
 	let nudgeTimer: ReturnType<typeof setTimeout> | undefined;
 	const pendingAskUserToolCallIds = new Set<string>();
@@ -233,19 +241,19 @@ export default function (pi: ExtensionAPI) {
 		registerTodoTool(pi, {
 			...thinkingPrompt,
 			...(availableThinkingLevels ? { parameters: todoParamsSchemaForThinkingLevels(availableThinkingLevels) } : {}),
-			prepareMutation: (state, _ctx, info) => {
+			prepareMutation: (state, ctx, info) => {
 				if (!todoThinkingEnabled) return info.params;
-				if (info.action === "create" || info.action === "update") return prepareTodoThinkingMutation(state, info.params);
+				if (info.action === "create" || info.action === "update") return prepareTodoThinkingMutation(state, ctx, info.params);
 				if (info.action === "batch_create" || info.action === "batch_update") {
 					return {
 						...info.params,
-						items: (info.params.items ?? []).map((item) => prepareTodoThinkingMutation(state, item)),
+						items: (info.params.items ?? []).map((item) => prepareTodoThinkingMutation(state, ctx, item)),
 					};
 				}
 				return info.params;
 			},
 			afterCommit: async (state, ctx, info) => {
-				if (todoThinkingEnabled) applyTodoThinkingAfterCommit(state, info);
+				if (todoThinkingEnabled) applyTodoThinkingAfterCommit(state, ctx, info);
 				try {
 					const sync = syncPersistedPlan(ctx.cwd, info.committedState);
 					if (sync?.completed) console.log(`rpiv-todo: completed persisted plan and removed ${sync.path}`);
@@ -256,20 +264,27 @@ export default function (pi: ExtensionAPI) {
 		});
 	}
 
-	function applyTodoThinkingAfterCommit(state: ReturnType<typeof getState>, info: { action: string; params: TaskMutationParams }): void {
+	function applyTodoThinkingAfterCommit(
+		state: ReturnType<typeof getState>,
+		ctx: ExtensionContext,
+		info: { action: string; params: TaskMutationParams },
+	): void {
 		const mutations = getTodoThinkingMutations(info.action, info.params);
-		for (const mutation of mutations) {
-			if (mutation.id === undefined || mutation.status === "in_progress") continue;
-			restoreTaskThinking(mutation.id, state);
-		}
-		restoreInactiveTodoThinking(state);
-		for (const mutation of mutations) {
-			if (mutation.id === undefined) continue;
-			const task = state.tasks.find((item) => item.id === mutation.id);
-			if (!task || task.status !== "in_progress" || !task.thinking) continue;
-			if (mutation.status !== "in_progress" && mutation.thinking === undefined) continue;
-			switchToTaskThinking(task.id, task.thinking);
+		const activeTasks = state.tasks.filter((task) => task.status === "in_progress" && task.thinking !== undefined);
+		if (activeTasks.length === 0) {
+			restoreTodoThinkingBaseline(state, ctx);
+			return;
 		}
+
+		rememberTodoThinkingBaseline(state, ctx);
+		const explicitlyActivated = [...mutations].reverse().find((mutation) => {
+			if (mutation.id === undefined || (mutation.status !== "in_progress" && mutation.thinking === undefined)) return false;
+			return activeTasks.some((task) => task.id === mutation.id);
+		});
+		let target: Task | undefined;
+		if (explicitlyActivated) target = activeTasks.find((task) => task.id === explicitlyActivated.id);
+		else if (activeTasks.length === 1) [target] = activeTasks;
+		if (target?.thinking) switchToTaskThinking(target.thinking);
 	}
 
 	function getTodoThinkingMutations(action: string, params: TaskMutationParams): TaskMutationParams[] {
@@ -283,7 +298,43 @@ export default function (pi: ExtensionAPI) {
 		return isTodoThinkingLevel(level) ? level : undefined;
 	}
 
-	function prepareTodoThinkingMutation(state: ReturnType<typeof getState>, params: TaskMutationParams): TaskMutationParams {
+	function thinkingScopeKey(ctx: ExtensionContext): string {
+		return todoStateScopeFromContext(ctx) ?? "__default__";
+	}
+
+	function storedRestoreThinking(task: Task): TodoThinkingLevel | undefined {
+		const stored = task.metadata?.[TODO_THINKING_RESTORE_METADATA_KEY];
+		return isTodoThinkingLevel(stored) ? stored : undefined;
+	}
+
+	function storedTodoThinkingBaseline(state: ReturnType<typeof getState>, activeOnly: boolean): TodoThinkingLevel | undefined {
+		for (const task of state.tasks) {
+			if (activeOnly && task.status !== "in_progress") continue;
+			const stored = storedRestoreThinking(task);
+			if (stored) return stored;
+		}
+		return undefined;
+	}
+
+	function getTodoThinkingBaseline(state: ReturnType<typeof getState>, ctx: ExtensionContext): TodoThinkingLevel | undefined {
+		return baselineThinkingByScope.get(thinkingScopeKey(ctx)) ?? storedTodoThinkingBaseline(state, true);
+	}
+
+	function rememberTodoThinkingBaseline(state: ReturnType<typeof getState>, ctx: ExtensionContext): void {
+		const scopeKey = thinkingScopeKey(ctx);
+		if (baselineThinkingByScope.has(scopeKey)) return;
+		const baseline = storedTodoThinkingBaseline(state, true);
+		if (baseline) baselineThinkingByScope.set(scopeKey, baseline);
+	}
+
+	function syncTodoThinkingBaseline(state: ReturnType<typeof getState>, ctx: ExtensionContext): void {
+		const scopeKey = thinkingScopeKey(ctx);
+		const baseline = storedTodoThinkingBaseline(state, true);
+		if (baseline) baselineThinkingByScope.set(scopeKey, baseline);
+		else baselineThinkingByScope.delete(scopeKey);
+	}
+
+	function prepareTodoThinkingMutation(state: ReturnType<typeof getState>, ctx: ExtensionContext, params: TaskMutationParams): TaskMutationParams {
 		let nextParams = params;
 		const configuredOverride = resolveTodoThinkingOverride(currentModel, todoThinkingOverrides);
 		if (configuredOverride !== undefined) {
@@ -305,49 +356,33 @@ export default function (pi: ExtensionAPI) {
 		const shouldCapturePreviousThinking =
 			nextStatus === "in_progress" && nextThinking !== undefined && (current.status !== "in_progress" || nextParams.thinking !== undefined);
 		if (!shouldCapturePreviousThinking) return nextParams;
-		const currentThinking = getCurrentThinkingLevel();
-		if (!currentThinking) return nextParams;
+		const baselineThinking = getTodoThinkingBaseline(state, ctx) ?? getCurrentThinkingLevel();
+		if (!baselineThinking) return nextParams;
 		return {
 			...nextParams,
 			metadata: {
 				...(nextParams.metadata ?? {}),
-				[TODO_THINKING_RESTORE_METADATA_KEY]: currentThinking,
+				[TODO_THINKING_RESTORE_METADATA_KEY]: baselineThinking,
 			},
 		};
 	}
 
-	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 {
+	function switchToTaskThinking(level: TodoThinkingLevel): void {
 		if (!getAvailableTodoThinkingLevels(currentModel).includes(level)) return;
 		const current = getCurrentThinkingLevel();
 		if (!current) return;
-		if (!rememberedThinkingByTaskId.has(taskId)) rememberedThinkingByTaskId.set(taskId, current);
 		if (current !== level) setTodoThinkingLevel(level);
 	}
 
-	function restoreTaskThinking(taskId: number, state: ReturnType<typeof getState>): void {
-		const previous = getRememberedThinking(taskId, state);
+	function restoreTodoThinkingBaseline(state: ReturnType<typeof getState>, ctx: ExtensionContext): void {
+		const scopeKey = thinkingScopeKey(ctx);
+		const previous = baselineThinkingByScope.get(scopeKey) ?? storedTodoThinkingBaseline(state, false);
 		if (!previous) return;
-		rememberedThinkingByTaskId.delete(taskId);
+		baselineThinkingByScope.delete(scopeKey);
 		const restored = normalizeTodoThinkingLevelForModel(currentModel, previous);
 		if (getCurrentThinkingLevel() !== restored) setTodoThinkingLevel(restored);
 	}
 
-	function restoreInactiveTodoThinking(state: ReturnType<typeof getState>): void {
-		for (const taskId of [...rememberedThinkingByTaskId.keys()]) {
-			const task = state.tasks.find((item) => item.id === taskId);
-			if (task?.status === "in_progress") continue;
-			restoreTaskThinking(taskId, state);
-		}
-	}
-
 	function setTodoThinkingLevel(level: TodoThinkingLevel): void {
 		const setter = (pi as { setThinkingLevel?: (level: TodoThinkingLevel) => void }).setThinkingLevel;
 		if (!setter) return;
@@ -401,7 +436,7 @@ export default function (pi: ExtensionAPI) {
 		const autoClear = autoClearCompletedTodos(result.state);
 		replaceState(autoClear.state);
 		publishTodoState(pi as any, ctx, action, params as Record<string, unknown>);
-		if (todoThinkingEnabled) applyTodoThinkingAfterCommit(result.state, { action, params });
+		if (todoThinkingEnabled) applyTodoThinkingAfterCommit(result.state, ctx, { action, params });
 		try {
 			const sync = syncPersistedPlan(ctx.cwd, autoClear.state);
 			if (sync?.completed) console.log(`rpiv-todo: completed persisted plan and removed ${sync.path}`);
@@ -473,6 +508,7 @@ export default function (pi: ExtensionAPI) {
 		const persisted = loadPersistedPlan(ctx.cwd);
 		const loaded = autoClearCompletedTodos(persisted?.state ?? replayFromBranch(ctx));
 		replaceState(loaded.state);
+		if (todoThinkingEnabled) syncTodoThinkingBaseline(loaded.state, ctx);
 		publishTodoState(pi as any, ctx);
 		if (persisted && loaded.cleared) syncPersistedPlan(ctx.cwd, loaded.state);
 		lastNudgedSignature = undefined;
@@ -487,14 +523,18 @@ export default function (pi: ExtensionAPI) {
 
 	pi.on("session_compact", async (_event, ctx) => {
 		activateTodoStateScope(ctx);
-		replaceState(autoClearCompletedTodos(loadPersistedPlan(ctx.cwd)?.state ?? replayFromBranch(ctx)).state);
+		const state = autoClearCompletedTodos(loadPersistedPlan(ctx.cwd)?.state ?? replayFromBranch(ctx)).state;
+		replaceState(state);
+		if (todoThinkingEnabled) syncTodoThinkingBaseline(state, ctx);
 		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);
+		const state = autoClearCompletedTodos(loadPersistedPlan(ctx.cwd)?.state ?? replayFromBranch(ctx)).state;
+		replaceState(state);
+		if (todoThinkingEnabled) syncTodoThinkingBaseline(state, ctx);
 		publishTodoState(pi as any, ctx);
 		lastNudgedSignature = undefined;
 	});

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

@@ -202,7 +202,7 @@ function sessionIdFromContext(ctx: unknown): string | undefined {
 	return typeof sessionId === "string" && sessionId.trim() ? sessionId : undefined;
 }
 
-function todoStateScopeFromContext(ctx: unknown): string | undefined {
+export function todoStateScopeFromContext(ctx: unknown): string | undefined {
 	const sessionFile = sessionFileFromContext(ctx);
 	if (sessionFile) return `file:${resolve(sessionFile)}`;
 	const sessionId = sessionIdFromContext(ctx);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ui-extend",
-  "version": "1.0.24",
+  "version": "1.0.28",
   "description": "Pix: a workspace-first terminal UI for Pi with tabs, readable tool activity, voice input, and bundled agent tools.",
   "private": false,
   "repository": {