pi-ui-extend 1.0.11 → 1.0.13

package/dist/app/runtime.d.ts

@@ -46,6 +46,13 @@ type RuntimeSessionManagerModelState = Pick<SessionManager, "getEntries" | "getB
 export declare function resolvePixRuntimeModelRef(options: Pick<AppOptions, "modelRef">, sessionManager: RuntimeSessionManagerModelState, config?: PixConfig): string | undefined;
 export declare function resolvePixRuntimeInitialThinkingLevel(options: Pick<AppOptions, "modelRef">, sessionManager: RuntimeSessionManagerModelState, config: PixConfig): ThinkingLevel | undefined;
 export declare function resolveSessionModelRefFromTail(entries: readonly SessionEntry[]): string | undefined;
-export declare function refreshPixModelRuntimeForStartup(modelRuntime: Pick<AgentSessionServices["modelRuntime"], "refresh">): Promise<void>;
+/**
+ * pi-ai 0.84.2 predates GLM-5.3's final thinking contract. The released model
+ * is always-thinking and accepts exactly low/high/max via reasoning_effort.
+ * Patch the mutable catalog model before AgentSession clamps the selected level.
+ */
+export declare function patchGlm53ThinkingMetadata(model: unknown): boolean;
+export declare function patchPixModelRuntimeCompatibility(modelRuntime: Pick<AgentSessionServices["modelRuntime"], "getModels">): number;
+export declare function refreshPixModelRuntimeForStartup(modelRuntime: Pick<AgentSessionServices["modelRuntime"], "refresh" | "getModels">): Promise<void>;
 export declare function createPixRuntime(options: AppOptions, runtimeOptions?: CreatePixRuntimeOptions): Promise<AgentSessionRuntime>;
 export {};

package/dist/app/runtime.js

@@ -235,10 +235,49 @@ export function resolveSessionModelRefFromTail(entries) {
         return undefined;
     return thinkingLevel ? `${modelRef}:${thinkingLevel}` : modelRef;
 }
+const GLM_53_THINKING_LEVEL_MAP = {
+    off: null,
+    minimal: null,
+    low: "low",
+    medium: null,
+    high: "high",
+    xhigh: null,
+    max: "max",
+};
+/**
+ * pi-ai 0.84.2 predates GLM-5.3's final thinking contract. The released model
+ * is always-thinking and accepts exactly low/high/max via reasoning_effort.
+ * Patch the mutable catalog model before AgentSession clamps the selected level.
+ */
+export function patchGlm53ThinkingMetadata(model) {
+    if (!model || typeof model !== "object" || Array.isArray(model))
+        return false;
+    const candidate = model;
+    if (candidate.id !== "glm-5.3")
+        return false;
+    if (!candidate.compat || typeof candidate.compat !== "object" || Array.isArray(candidate.compat))
+        return false;
+    const compat = candidate.compat;
+    if (compat.thinkingFormat !== "zai")
+        return false;
+    candidate.reasoning = true;
+    candidate.thinkingLevelMap = { ...GLM_53_THINKING_LEVEL_MAP };
+    candidate.compat = { ...compat, supportsReasoningEffort: true };
+    return true;
+}
+export function patchPixModelRuntimeCompatibility(modelRuntime) {
+    let patched = 0;
+    for (const model of modelRuntime.getModels()) {
+        if (patchGlm53ThinkingMetadata(model))
+            patched += 1;
+    }
+    return patched;
+}
 export async function refreshPixModelRuntimeForStartup(modelRuntime) {
     // Startup only needs the locally configured model catalog. Remote catalog
     // refreshes belong to explicit model-management flows and must not block boot.
     await modelRuntime.refresh({ allowNetwork: false });
+    patchPixModelRuntimeCompatibility(modelRuntime);
 }
 export async function createPixRuntime(options, runtimeOptions = {}) {
     const agentDir = getAgentDir();

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

@@ -41,12 +41,24 @@ const DEFAULT_LOOKUP_MAX_IMAGES = 6;
 const DEFAULT_LOOKUP_MAX_TOKENS = 1_600;
 const DEFAULT_LOOKUP_TIMEOUT_MS = 120_000;
 const MAX_IMAGE_BYTES = 16 * 1024 * 1024;
-const SILENCE_REMINDER_MIN_VIOLATION_GAP = 3;
-const SILENCE_REMINDER_MIN_MESSAGE_GAP = 12;
+// Keep recovery nudges sparse: newer GLM coding models are substantially better at
+// long-horizon tool use, and repeated developer reminders can become prompt noise.
+const SILENCE_REMINDER_MIN_VIOLATION_GAP = 5;
+const SILENCE_REMINDER_MIN_MESSAGE_GAP = 20;
 // When the visible history shrinks by more than this many messages (compaction or
 // truncation), the chatter baseline is reset so it isn't measured against a stale peak.
 const SILENCE_REMINDER_COMPACTION_MARGIN = 8;
 const LOOKUP_TOOL_NAME = "lookup";
+const GLM_53_THINKING_LEVEL_MAP = {
+	off: null,
+	minimal: null,
+	low: "low",
+	medium: null,
+	high: "high",
+	xhigh: null,
+	max: "max",
+} as const;
+const GLM_53_THINKING_LEVELS = ["low", "high", "max"] as const;
 
 const LOOKUP_TOOL_PARAMS = Type.Object(
 	{
@@ -89,7 +101,9 @@ function buildDisciplineLines(strictness: CodingDisciplineStrictness): readonly
 		isStrict ? "- WORKING: exactly one next tool call with empty text;" : "- WORKING: one or more independent tool calls with empty text;",
 		"- FINAL: one final answer after completion or practical verification;",
 		"- BLOCKED: one concise question only when no safe/useful tool action can continue.",
-		"No transition permits commentary between tool calls.",
+		isStrict
+			? "No transition permits commentary between tool calls."
+			: "When a thinking/reasoning channel is available, do not duplicate that reasoning as visible commentary between tool calls.",
 		"",
 		"PRIORITY: this overrides default assistant friendliness and conversational behavior.",
 		"",
@@ -107,7 +121,7 @@ function buildDisciplineLines(strictness: CodingDisciplineStrictness): readonly
 const LOOKUP_DISCIPLINE_LINES = [
 	"",
 	"Visual lookup discipline:",
-	"The current GLM model may be unable to inspect images/screenshots directly.",
+	"Treat the current GLM coding endpoint as text-only; do not assume it can inspect images/screenshots directly.",
 	"When the user refers to an image, screenshot, UI visual bug, layout problem, arrow, annotation, highlight, visible text, chart, diagram, or any visual evidence, call the `lookup` tool before making visual claims.",
 	"Use a focused lookup query that includes the user's visual concern and asks the helper to pay attention to arrows, annotations, highlights, visible UI state, text, spacing/layout, and suspected bugs.",
 	"Treat lookup output as visual evidence; do not invent visual details beyond it.",
@@ -141,7 +155,8 @@ const DISCIPLINE_PROMPT_BLOCK_PATTERN = new RegExp(
  * Strips pi's built-in "Pi documentation" reference block from the system prompt.
  * That block (≈10 lines listing docs/examples paths and "when asked about X" routing)
  * is useless dead weight for non-pi work and dilutes attention to the trailing
- * <available_skills> section, which especially hurts weaker models like GLM.
+ * <available_skills> section and wastes attention that should stay on the task and
+ * the extension-provided agent contract.
  * Anchored on the fixed header/footer strings from buildSystemPrompt() so it only
  * ever matches pi's own block regardless of resolved doc/example paths.
  */
@@ -151,7 +166,7 @@ const PI_DOCS_BLOCK_PATTERN = new RegExp(
 );
 
 const LOOKUP_SYSTEM_PROMPT = [
-	"You are a vision-capable lookup helper for a blind GLM coding agent.",
+	"You are a vision-capable lookup helper for a text-only GLM coding agent.",
 	"Inspect the provided screenshots/images and answer the parent agent's focused question using concrete visual evidence.",
 	"Pay special attention to arrows, annotations, highlights, cursor position, visible UI state, text, layout, spacing, colors, overlays, visual bugs, and error messages.",
 	"Use recent session context only to understand what the user is asking; do not perform code changes.",
@@ -198,13 +213,17 @@ export default function codingDiscipline(pi: ExtensionAPI) {
 	maybeRegisterLookupTool(process.cwd());
 
 	pi.on("session_start", async (_event: unknown, ctx: unknown) => {
+		patchGlm53ThinkingModels(ctx);
 		selectedModelRef = modelRefFromContext(ctx);
+		normalizeCurrentGlm53ThinkingLevel(pi, selectedModelRef);
 		maybeRegisterLookupTool(contextCwd(ctx));
 		syncLookupToolAvailability(selectedModelRef, contextCwd(ctx));
 	});
 
 	pi.on("model_select", async (event: { model?: unknown }, ctx: unknown) => {
+		patchGlm53ThinkingModels(ctx, event.model);
 		selectedModelRef = modelRefFromModel(event.model) ?? modelRefFromContext(ctx);
+		normalizeCurrentGlm53ThinkingLevel(pi, selectedModelRef);
 		maybeRegisterLookupTool(contextCwd(ctx));
 		syncLookupToolAvailability(selectedModelRef, contextCwd(ctx));
 	});
@@ -217,10 +236,11 @@ export default function codingDiscipline(pi: ExtensionAPI) {
 			lookupEnabled: Boolean(lookupModelFromConfig(cwd)),
 			strictness: codingDisciplineStrictnessFromConfig(cwd),
 		});
+		const corrected = applyGlm53ThinkingToPayload(injected, modelRef, ctx, pi);
 		if (process.env.PI_DEBUG_PROMPT === "1") {
-			logFinalPrompt(injected, modelRef, contextCwd(ctx) ?? process.cwd());
+			logFinalPrompt(corrected, modelRef, contextCwd(ctx) ?? process.cwd());
 		}
-		return injected;
+		return corrected;
 	});
 
 	pi.on("before_agent_start", async (event: { systemPromptOptions?: unknown; systemPrompt?: string }, ctx: unknown) => {
@@ -345,6 +365,83 @@ export function isGlmModel(modelRef: string | undefined): boolean {
 	return /(?:^|[/:_.-])glm(?:$|[/:_.-]|\d)/i.test(modelRef);
 }
 
+function isGlm53ModelRef(modelRef: string | undefined): boolean {
+	if (!modelRef) return false;
+	return /(?:^|\/)glm-5\.3(?:$|:)/i.test(modelRef) || /^glm-5\.3(?:$|:)/i.test(modelRef);
+}
+
+function patchGlm53ThinkingModel(model: unknown): boolean {
+	if (!isRecord(model)) return false;
+	const id = typeof model.id === "string"
+		? model.id
+		: typeof model.modelId === "string"
+			? model.modelId
+			: undefined;
+	if (id !== "glm-5.3") return false;
+	const provider = typeof model.provider === "string" ? model.provider : undefined;
+	const compat = isRecord(model.compat) ? model.compat : {};
+	if (provider !== "zai" && provider !== "zai-coding-cn" && compat.thinkingFormat !== "zai") return false;
+
+	model.reasoning = true;
+	model.thinkingLevelMap = { ...GLM_53_THINKING_LEVEL_MAP };
+	model.compat = { ...compat, supportsReasoningEffort: true };
+	return true;
+}
+
+function patchGlm53ThinkingModels(ctx: unknown, selectedModel?: unknown): void {
+	patchGlm53ThinkingModel(selectedModel);
+	if (!isRecord(ctx)) return;
+	patchGlm53ThinkingModel(ctx.model);
+
+	if (Array.isArray(ctx.scopedModels)) {
+		for (const entry of ctx.scopedModels) {
+			if (isRecord(entry)) patchGlm53ThinkingModel(entry.model);
+		}
+	}
+
+	const registry = ctx.modelRegistry;
+	if (!isRecord(registry) || typeof registry.getAll !== "function") return;
+	try {
+		const models = registry.getAll();
+		if (Array.isArray(models)) {
+			for (const model of models) patchGlm53ThinkingModel(model);
+		}
+	} catch {
+		// Compatibility patching must never break session startup.
+	}
+}
+
+function normalizeGlm53ThinkingLevel(level: unknown): (typeof GLM_53_THINKING_LEVELS)[number] {
+	if (level === "low" || level === "high" || level === "max") return level;
+	if (level === "off" || level === "minimal") return "low";
+	if (level === "medium") return "high";
+	return "max";
+}
+
+function normalizeCurrentGlm53ThinkingLevel(pi: ExtensionAPI, modelRef: string | undefined): void {
+	if (!isGlm53ModelRef(modelRef)) return;
+	const getter = (pi as { getThinkingLevel?: () => unknown }).getThinkingLevel;
+	const setter = (pi as { setThinkingLevel?: (level: string) => void }).setThinkingLevel;
+	if (!getter || !setter) return;
+	const current = getter.call(pi);
+	const normalized = normalizeGlm53ThinkingLevel(current);
+	if (current !== normalized) setter.call(pi, normalized);
+}
+
+function applyGlm53ThinkingToPayload(payload: unknown, modelRef: string | undefined, ctx: unknown, pi: ExtensionAPI): unknown {
+	if (!isGlm53ModelRef(modelRef) || !isRecord(payload)) return payload;
+	const getter = (pi as { getThinkingLevel?: () => unknown }).getThinkingLevel;
+	const runtimeLevel = getter ? getter.call(pi) : undefined;
+	const contextLevel = isRecord(ctx) ? ctx.thinkingLevel : undefined;
+	const effort = normalizeGlm53ThinkingLevel(runtimeLevel ?? contextLevel);
+	const existingThinking = isRecord(payload.thinking) ? payload.thinking : {};
+	return {
+		...payload,
+		thinking: { ...existingThinking, type: "enabled", clear_thinking: false },
+		reasoning_effort: effort,
+	};
+}
+
 export function injectCodingDisciplineIntoPayload(payload: unknown, options: DisciplinePromptOptions = {}): unknown {
 	if (!isRecord(payload)) return payload;
 
@@ -676,7 +773,7 @@ function codingDisciplineStrictnessFromConfig(cwd?: string): CodingDisciplineStr
 
 function buildLookupPrompt(params: LookupParams, recentContext: string, imageCount: number, warnings: string[]): string {
 	return [
-		"Lookup request from a blind GLM parent model.",
+		"Lookup request from a text-only GLM parent model.",
 		"",
 		"Focused question:",
 		params.query.trim(),

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

@@ -8,7 +8,13 @@ import { ACTIVE_STATUSES, isTaskBlocked, selectVisibleTasks } from "./state/sele
 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 type { Task, TaskMutationParams } from "./tool/types.js";
+import {
+	TODO_THINKING_LEVEL_VALUES,
+	todoParamsSchemaForThinkingLevels,
+	type Task,
+	type TaskMutationParams,
+	type TodoThinkingLevel,
+} from "./tool/types.js";
 
 type AgentMessageLike = { role?: unknown; stopReason?: unknown; content?: unknown };
 
@@ -17,39 +23,73 @@ const TODO_NUDGE_INITIAL_DELAY_MS = 0;
 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", "max"] 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>> };
+type ModelLike = {
+	provider?: string;
+	id?: string;
+	modelId?: string;
+	reasoning?: boolean;
+	thinkingLevelMap?: Partial<Record<TodoThinkingLevel, unknown | null>>;
+	compat?: { thinkingFormat?: unknown };
+};
 
 function isTodoThinkingLevel(value: unknown): value is TodoThinkingLevel {
-	return TODO_THINKING_LEVELS.includes(value as TodoThinkingLevel);
+	return TODO_THINKING_LEVEL_VALUES.includes(value as TodoThinkingLevel);
+}
+
+function isGlm53TodoModel(model: ModelLike | undefined): boolean {
+	if (!model) return false;
+	const id = model.modelId ?? model.id;
+	if (id !== "glm-5.3") return false;
+	return model.provider === "zai" || model.provider === "zai-coding-cn" || model.compat?.thinkingFormat === "zai";
 }
 
 function getAvailableTodoThinkingLevels(model: unknown): TodoThinkingLevel[] {
 	const m = model as ModelLike | undefined;
 	if (!m?.reasoning) return ["off"];
+	if (isGlm53TodoModel(m)) return ["low", "high", "max"];
 	const map = m.thinkingLevelMap;
-	return TODO_THINKING_LEVELS.filter((level) => level === "off" || map?.[level] !== null);
+	return TODO_THINKING_LEVEL_VALUES.filter((level) => {
+		const mapped = map?.[level];
+		if (mapped === null) return false;
+		if (level === "xhigh" || level === "max") return mapped !== undefined;
+		return true;
+	});
 }
 
 function buildThinkingPromptParts(model: unknown): { promptSnippet?: string; promptGuidelines?: string[] } {
 	const levels = getAvailableTodoThinkingLevels(model);
 	if (levels.length <= 1) return {};
+	const lowEffortWording = levels.includes("off") ? "lower/off" : "lower";
 	return {
 		promptSnippet: `${DEFAULT_PROMPT_SNIPPET} Set per-item thinking: ${levels.join("|")}.`.trim(),
 		promptGuidelines: [
 			...DEFAULT_PROMPT_GUIDELINES,
-			`If todoThinking is enabled, set \`thinking\` on every planned task during create/batch_create (or update); choose from ${levels.join(", ")}. Use higher thinking for investigation, hard debugging, risky edits, or review; use lower/off for mechanical steps and the final report. Never leave it unset in a non-trivial plan.`,
+			`If todoThinking is enabled, set \`thinking\` on every planned task during create/batch_create (or update); choose from ${levels.join(", ")}. Use higher thinking for investigation, hard debugging, risky edits, or review; use ${lowEffortWording} for mechanical steps and the final report. Never leave it unset in a non-trivial plan.`,
 		],
 	};
 }
 
+function normalizeTodoThinkingLevelForModel(model: unknown, level: TodoThinkingLevel): TodoThinkingLevel {
+	const available = getAvailableTodoThinkingLevels(model);
+	if (available.includes(level)) return level;
+	const requestedIndex = TODO_THINKING_LEVEL_VALUES.indexOf(level);
+	for (let index = requestedIndex; index < TODO_THINKING_LEVEL_VALUES.length; index += 1) {
+		const candidate = TODO_THINKING_LEVEL_VALUES[index];
+		if (candidate && available.includes(candidate)) return candidate;
+	}
+	for (let index = requestedIndex - 1; index >= 0; index -= 1) {
+		const candidate = TODO_THINKING_LEVEL_VALUES[index];
+		if (candidate && available.includes(candidate)) return candidate;
+	}
+	return available[0] ?? "off";
+}
+
 function isAskUserToolName(toolName: string): boolean {
 	return ASK_USER_TOOL_NAMES.has(toolName);
 }
@@ -140,13 +180,15 @@ export default function (pi: ExtensionAPI) {
 	let settledNudgeEligible = false;
 
 	function registerTodoToolWithCurrentPrompt(): void {
+		const availableThinkingLevels = todoThinkingEnabled ? getAvailableTodoThinkingLevels(currentModel) : undefined;
 		const thinkingPrompt = todoThinkingEnabled ? buildThinkingPromptParts(currentModel) : {};
 		registerTodoTool(pi, {
 			...thinkingPrompt,
+			...(availableThinkingLevels ? { parameters: todoParamsSchemaForThinkingLevels(availableThinkingLevels) } : {}),
 			prepareMutation: (state, _ctx, info) => {
 				if (!todoThinkingEnabled) return info.params;
-				if (info.action === "update") return prepareTodoThinkingMutation(state, info.params);
-				if (info.action === "batch_update") {
+				if (info.action === "create" || info.action === "update") return prepareTodoThinkingMutation(state, info.params);
+				if (info.action === "batch_create" || info.action === "batch_update") {
 					return {
 						...info.params,
 						items: (info.params.items ?? []).map((item) => prepareTodoThinkingMutation(state, item)),
@@ -194,20 +236,29 @@ export default function (pi: ExtensionAPI) {
 	}
 
 	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;
+		let nextParams = params;
+		if (params.thinking !== undefined) {
+			const normalized = normalizeTodoThinkingLevelForModel(currentModel, params.thinking);
+			if (normalized !== params.thinking) nextParams = { ...nextParams, thinking: normalized };
+		}
+		if (nextParams.id === undefined) return nextParams;
+		const current = state.tasks.find((task) => task.id === nextParams.id);
+		if (!current) return nextParams;
+		const nextStatus = nextParams.status ?? current.status;
+		if (nextStatus === "in_progress" && nextParams.thinking === undefined && current.thinking !== undefined) {
+			const normalized = normalizeTodoThinkingLevelForModel(currentModel, current.thinking);
+			if (normalized !== current.thinking) nextParams = { ...nextParams, thinking: normalized };
+		}
+		const nextThinking = nextParams.thinking ?? current.thinking;
 		const shouldCapturePreviousThinking =
-			nextStatus === "in_progress" && nextThinking !== undefined && (current.status !== "in_progress" || params.thinking !== undefined);
-		if (!shouldCapturePreviousThinking) return params;
+			nextStatus === "in_progress" && nextThinking !== undefined && (current.status !== "in_progress" || nextParams.thinking !== undefined);
+		if (!shouldCapturePreviousThinking) return nextParams;
 		const currentThinking = getCurrentThinkingLevel();
-		if (!currentThinking) return params;
+		if (!currentThinking) return nextParams;
 		return {
-			...params,
+			...nextParams,
 			metadata: {
-				...(params.metadata ?? {}),
+				...(nextParams.metadata ?? {}),
 				[TODO_THINKING_RESTORE_METADATA_KEY]: currentThinking,
 			},
 		};
@@ -233,7 +284,8 @@ export default function (pi: ExtensionAPI) {
 		const previous = getRememberedThinking(taskId, state);
 		if (!previous) return;
 		rememberedThinkingByTaskId.delete(taskId);
-		if (getCurrentThinkingLevel() !== previous) setTodoThinkingLevel(previous);
+		const restored = normalizeTodoThinkingLevelForModel(currentModel, previous);
+		if (getCurrentThinkingLevel() !== restored) setTodoThinkingLevel(restored);
 	}
 
 	function restoreInactiveTodoThinking(state: ReturnType<typeof getState>): void {

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

@@ -91,6 +91,7 @@ interface TodoToolHooks {
 interface TodoToolRegistrationOptions extends TodoToolHooks {
 	promptSnippet?: string;
 	promptGuidelines?: string[];
+	parameters?: typeof TodoParamsSchema;
 }
 
 type TodoStateEventContext = { sessionManager?: { getSessionFile?: () => unknown; getSessionId?: () => unknown } };
@@ -391,7 +392,7 @@ export function registerTodoTool(pi: ExtensionAPI, hooks: TodoToolRegistrationOp
 		label: TOOL_LABEL,
 		promptSnippet: hooks.promptSnippet ?? DEFAULT_PROMPT_SNIPPET,
 		promptGuidelines: hooks.promptGuidelines ?? DEFAULT_PROMPT_GUIDELINES,
-		parameters: TodoParamsSchema,
+		parameters: hooks.parameters ?? TodoParamsSchema,
 
 		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
 			activateTodoStateScope(_ctx);

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

@@ -24,7 +24,8 @@ export const MSG_NO_TODOS = "No todos yet. Ask the agent to add some!";
 // ---------------------------------------------------------------------------
 
 export type TaskStatus = "pending" | "in_progress" | "deferred" | "completed" | "deleted";
-export type TodoThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+export const TODO_THINKING_LEVEL_VALUES = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
+export type TodoThinkingLevel = (typeof TODO_THINKING_LEVEL_VALUES)[number];
 
 export type TaskAction = "create" | "update" | "batch_create" | "batch_update" | "list" | "get" | "delete" | "clear" | "export" | "import";
 
@@ -104,7 +105,7 @@ export const TodoParamsSchema = Type.Object({
 		}),
 	),
 	thinking: Type.Optional(
-		StringEnum(["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const, {
+		StringEnum(TODO_THINKING_LEVEL_VALUES, {
 			description: "Per-task thinking level used when todoThinking is enabled and this task is in_progress",
 		}),
 	),
@@ -164,4 +165,20 @@ export const TodoParamsSchema = Type.Object({
 	replace: Type.Optional(Type.Boolean({ description: "For import/create/batch_create, replace existing tasks instead of appending. Use batch_create with replace:true when starting a new plan that supersedes old unfinished todos. Default: false." })),
 });
 
+export function todoParamsSchemaForThinkingLevels(levels: readonly TodoThinkingLevel[]): typeof TodoParamsSchema {
+	const supported = TODO_THINKING_LEVEL_VALUES.filter((level) => levels.includes(level));
+	const effective = supported.length > 0 ? supported : ["off"];
+	return {
+		...TodoParamsSchema,
+		properties: {
+			...TodoParamsSchema.properties,
+			thinking: Type.Optional(
+				StringEnum(effective as unknown as typeof TODO_THINKING_LEVEL_VALUES, {
+					description: "Per-task thinking level used when todoThinking is enabled and this task is in_progress",
+				}),
+			),
+		},
+	} as typeof TodoParamsSchema;
+}
+
 export type TodoParams = Static<typeof TodoParamsSchema>;

package/package.json

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