pi-ui-extend 0.1.34 → 0.1.35

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());
 }

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

@@ -13,6 +13,7 @@
  */
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { resolve } from "node:path";
 import { TODO_TOOL_DESCRIPTION } from "../tool-descriptions.js";
 import {
 	disablePersistence,
@@ -25,7 +26,7 @@ import { AUTO_CLEAR_COMPLETED_MESSAGE, autoClearCompletedTodos } from "./state/a
 import { replayFromBranch } from "./state/replay.js";
 import { isTaskBlocked, selectTasksByStatus, selectTodoCounts } from "./state/selectors.js";
 import { applyTaskMutation } from "./state/state-reducer.js";
-import { commitState, getState, replaceState } from "./state/store.js";
+import { activateStateScope, commitState, getState, replaceState } from "./state/store.js";
 import { buildToolResult, formatContent } from "./tool/response-envelope.js";
 import {
 	COMMAND_NAME,
@@ -75,7 +76,16 @@ const PERSIST_ARGUMENT_COMPLETIONS: CommandCompletion[] = [
 ];
 
 interface TodoToolHooks {
-	afterCommit?: (state: ReturnType<typeof getState>, ctx: ExtensionContext, info: { action: TaskAction; params: TaskMutationParams }) => void | Promise<void>;
+	prepareMutation?: (
+		state: ReturnType<typeof getState>,
+		ctx: ExtensionContext,
+		info: { action: TaskAction; params: TaskMutationParams },
+	) => TaskMutationParams | Promise<TaskMutationParams>;
+	afterCommit?: (
+		state: ReturnType<typeof getState>,
+		ctx: ExtensionContext,
+		info: { action: TaskAction; params: TaskMutationParams; committedState: ReturnType<typeof getState> },
+	) => void | Promise<void>;
 }
 
 interface TodoToolRegistrationOptions extends TodoToolHooks {
@@ -83,7 +93,7 @@ interface TodoToolRegistrationOptions extends TodoToolHooks {
 	promptGuidelines?: string[];
 }
 
-type TodoStateEventContext = { sessionManager?: { getSessionFile?: () => unknown } };
+type TodoStateEventContext = { sessionManager?: { getSessionFile?: () => unknown; getSessionId?: () => unknown } };
 type TodoStateEventEmitter = { events?: { emit?: (channel: string, data: unknown) => void } };
 
 interface TodosCommandOptions {
@@ -183,14 +193,34 @@ function sessionFileFromContext(ctx: unknown): string | undefined {
 	return typeof sessionFile === "string" && sessionFile.trim() ? sessionFile : undefined;
 }
 
+function sessionIdFromContext(ctx: unknown): string | undefined {
+	const sessionId = (ctx as TodoStateEventContext | undefined)?.sessionManager?.getSessionId?.();
+	return typeof sessionId === "string" && sessionId.trim() ? sessionId : undefined;
+}
+
+function todoStateScopeFromContext(ctx: unknown): string | undefined {
+	const sessionFile = sessionFileFromContext(ctx);
+	if (sessionFile) return `file:${resolve(sessionFile)}`;
+	const sessionId = sessionIdFromContext(ctx);
+	if (sessionId) return `id:${sessionId}`;
+	const cwd = (ctx as { cwd?: unknown } | undefined)?.cwd;
+	return typeof cwd === "string" && cwd.trim() ? `cwd:${resolve(cwd)}` : undefined;
+}
+
+export function activateTodoStateScope(ctx: unknown): void {
+	activateStateScope(todoStateScopeFromContext(ctx));
+}
+
 export function publishTodoState(
 	pi: TodoStateEventEmitter,
 	ctx: unknown,
 	action: TaskAction = "list",
 	params: Record<string, unknown> = {},
 ): void {
+	activateTodoStateScope(ctx);
 	const state = getState();
 	const sessionFile = sessionFileFromContext(ctx);
+	const sessionId = sessionIdFromContext(ctx);
 	pi.events?.emit?.(TODO_STATE_EVENT, {
 		version: 1,
 		details: {
@@ -200,6 +230,7 @@ export function publishTodoState(
 			nextId: state.nextId,
 		},
 		...(sessionFile ? { sessionFile } : {}),
+		...(sessionId ? { sessionId } : {}),
 		checkedAt: Date.now(),
 	});
 }
@@ -363,15 +394,24 @@ export function registerTodoTool(pi: ExtensionAPI, hooks: TodoToolRegistrationOp
 		parameters: TodoParamsSchema,
 
 		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-			const result = applyTaskMutation(getState(), params.action, params as TaskMutationParams);
+			activateTodoStateScope(_ctx);
+			const preparedParams = await hooks.prepareMutation?.(getState(), _ctx as ExtensionContext, {
+				action: params.action,
+				params: params as TaskMutationParams,
+			}) ?? params as TaskMutationParams;
+			const result = applyTaskMutation(getState(), params.action, preparedParams);
 			if (result.op.kind === "error") {
 				throw new Error(result.op.message);
 			}
 			const autoClear = autoClearCompletedTodos(result.state);
 			commitState(autoClear.state);
 			publishTodoState(pi as TodoStateEventEmitter, _ctx, params.action, params as Record<string, unknown>);
-			await hooks.afterCommit?.(autoClear.state, _ctx as ExtensionContext, { action: params.action, params: params as TaskMutationParams });
-			const toolResult = buildToolResult(params.action, params as TaskMutationParams, autoClear.state, result.op);
+			await hooks.afterCommit?.(result.state, _ctx as ExtensionContext, {
+				action: params.action,
+				params: preparedParams,
+				committedState: autoClear.state,
+			});
+			const toolResult = buildToolResult(params.action, preparedParams, autoClear.state, result.op);
 			if (!autoClear.cleared) return toolResult;
 			return {
 				...toolResult,
@@ -391,6 +431,7 @@ export function registerTodosCommand(pi: ExtensionAPI): void {
 	description: "Show todos on the current branch. Flags: --active, --ready, --blocked, --tree, --status <status>, --export [json|markdown]. Commands: persist on|off|clear|status, scope <id...>",
 		getArgumentCompletions: (prefix) => completeCommandArguments(String(prefix ?? ""), TODOS_ARGUMENT_COMPLETIONS),
 		handler: async (args, ctx) => {
+			activateTodoStateScope(ctx);
 			if (handlePersistCommand(args, ctx)) return;
 			if (handleScopeCommand(args, ctx, () => publishTodoState(pi as TodoStateEventEmitter, ctx))) return;
 			if (!ctx.hasUI) {
@@ -459,6 +500,7 @@ export function registerTodosCommand(pi: ExtensionAPI): void {
 		description: "Enable, disable, clear, or inspect project todo persistence. Args: on|off|clear|status.",
 		getArgumentCompletions: (prefix) => completeCommandArguments(String(prefix ?? ""), PERSIST_ARGUMENT_COMPLETIONS),
 		handler: async (args, ctx) => {
+			activateTodoStateScope(ctx);
 			handlePersistCommand(`persist ${getCommandText(args)}`, ctx);
 		},
 	});
@@ -466,6 +508,7 @@ export function registerTodosCommand(pi: ExtensionAPI): void {
 	pi.registerCommand(SCOPE_COMMAND_NAME, {
 		description: "Select todo ids to continue from a persisted plan; pending/in_progress items outside the scope become deferred.",
 		handler: async (args, ctx) => {
+			activateTodoStateScope(ctx);
 			handleScopeCommand(`scope ${getCommandText(args)}`, ctx, () => publishTodoState(pi as TodoStateEventEmitter, ctx));
 		},
 	});

package/external/pi-tools-suite/src/tool-descriptions.ts

@@ -27,10 +27,10 @@ export const COMPRESS_TOOL_DESCRIPTION: ToolDescription = {
 	name: "compress",
 	label: "Compress Context",
 	description: COMPRESS_RANGE_DESCRIPTION,
-	promptSnippet: "Compress closed conversation slices as steady context housekeeping; after implementation + verification, compress before replying or starting a new task unless exact raw logs/diffs are still needed.",
+	promptSnippet: "Compress closed conversation slices as steady context housekeeping; before any new search/read/test/web lookup, compress older completed work unless exact raw text is still needed.",
 	promptGuidelines: [
-		"Treat completed implementation + verification slices as compression candidates immediately, not only at context-limit warnings.",
-		"Do not carry large stale tool outputs, diffs, or exploration logs across task boundaries; summarize their actionable result instead.",
+		"Treat completed implementation, verification, config/doc edits, answered exploration, dead ends, and log inspection as compression candidates immediately.",
+		"Do not carry large stale shell/read/repo/web outputs, diffs, or passing logs across task boundaries; summarize their actionable result instead.",
 		"Keep active, still-needed context raw; compress only closed ranges whose exact content is unlikely to be needed next.",
 	],
 };
@@ -329,7 +329,7 @@ export const CODEX_ALIAS_TOOL_DESCRIPTIONS = {
 	shellCommand: {
 		name: "shell",
 		label: "shell",
-		description: "Run shell commands for builds, tests, package managers, git, and project CLIs. Prefer tail for long test output. Set workdir/cwd instead of cd; prefer read for simple file reads.",
+		description: "Run shell commands for builds, tests, package managers, git, and project CLIs. For long/verification output, redirect to a log and show only bounded tail on failure; summarize passing logs. Set workdir/cwd instead of cd; prefer read for simple file reads.",
 	},
 	applyPatch: {
 		name: "apply_patch",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ui-extend",
-  "version": "0.1.34",
+  "version": "0.1.35",
   "private": false,
   "type": "module",
   "bin": {
@@ -43,12 +43,14 @@
     "watch:pix": "npm run link:pix --silent && mise exec node@24.16.0 -- tsc -p tsconfig.json --watch --preserveWatchOutput --noEmitOnError",
     "check": "mise exec node@24.16.0 -- npm run check:inner",
     "precheck:inner": "npm run generate-schemas --silent",
-    "check:inner": "tsc --noEmit && npm run test:inner",
+    "check:inner": "npm run sync:sdk-pin:check --silent && tsc --noEmit && npm run test:inner",
     "test": "mise exec node@24.16.0 -- npm run test:inner",
     "test:inner": "node --import tsx --test \"tests/**/*.test.ts\"",
     "test:tools-suite": "npm --prefix external/pi-tools-suite test",
     "sync:pi-tools-suite": "node scripts/sync-pi-tools-suite.mjs",
     "sync:pi-tools-suite:check": "node scripts/sync-pi-tools-suite.mjs --check",
+    "sync:sdk-pin": "node scripts/sync-sdk-pin.mjs",
+    "sync:sdk-pin:check": "node scripts/sync-sdk-pin.mjs --check",
     "test:coverage": "mise exec node@24.16.0 -- node --import tsx --test --experimental-test-coverage --test-coverage-include=src/**/*.ts --test-coverage-exclude=src/main.ts --test-coverage-lines=95 --test-coverage-branches=80 --test-coverage-functions=95 \"tests/**/*.test.ts\"",
     "update-sdk-references": "mise exec node@24.16.0 -- node .pi/skills/pi-sdk/scripts/update-references.mjs",
     "prepack": "npm run generate-schemas --silent",
@@ -62,9 +64,9 @@
     "prepublishOnly": "npm run check && npm run build:pix && npm run generate-schemas"
   },
   "dependencies": {
-    "@earendil-works/pi-ai": "0.79.3",
-    "@earendil-works/pi-coding-agent": "0.79.3",
-    "@earendil-works/pi-tui": "0.79.3",
+    "@earendil-works/pi-ai": "0.79.4",
+    "@earendil-works/pi-coding-agent": "0.79.4",
+    "@earendil-works/pi-tui": "0.79.4",
     "@mariozechner/clipboard": "^0.3.9",
     "jsonc-parser": "3.3.1",
     "typebox": "1.1.38",