pi-ui-extend 1.0.12 → 1.0.14

package/README.md

@@ -34,7 +34,7 @@ Pi provides the agent runtime, models, tools, skills, extensions, and persistent
 - **Keep projects organized.** Tabs are scoped to the working directory and survive restarts. Search, resume, fork, clone, jump through, import, export, share, or delete sessions without leaving the terminal.
 - **Stay in flow.** Run quick commands with `!`, open a raw interactive terminal with `!!`, paste images, follow file links, dictate in English or Russian, and improve a prompt before sending it.
 - **Know what the agent is doing.** The status area exposes model, thinking level, context, usage, workspace, todos, sub-agents, voice state, and prompt actions — with mouse targets where useful.
-- **Bring a serious toolkit.** Pix ships with `pi-tools-suite`: 17 integrated modules for indexed repository discovery, AST edits, LSP diagnostics, parallel agents, durable todos, context compression, web access, provider accounts, and more.
+- **Bring a serious toolkit.** Pix ships with `pi-tools-suite`: 18 integrated modules for indexed repository discovery, AST edits, LSP diagnostics, parallel agents, durable todos, context compression, web access, provider accounts, and more.
 - **Use the models you want.** Pix runs on Pi's provider ecosystem and supports model switching, scoped model lists, per-model thinking levels, usage views, autocomplete, and fallback-aware helper workflows.
 
 Pix is not a separate agent protocol or an RPC wrapper around Pi. It runs on the Pi SDK, so the runtime, session format, extensions, skills, prompts, and tools remain part of the same ecosystem.

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/dist/app/session/session-event-controller.d.ts

@@ -125,6 +125,15 @@ export declare class AppSessionEventController {
     }): Promise<boolean>;
     handleSessionEvent(event: AgentSessionEvent): void;
     private retryFailedTurn;
+    /**
+     * The SDK only emits `auto_retry_end` (whose toast carries the Retry button)
+     * when auto-retry actually runs. When retry is disabled, a transient streaming
+     * error such as a 429 rate limit surfaces only as the error entry above, with
+     * no way to resume the failed turn. Offer a manual Retry toast in that case,
+     * mirroring the auto-retry path. User aborts and non-retryable errors are
+     * excluded, and retry being enabled means the auto-retry toast will handle it.
+     */
+    private showManualRetryOnTerminalError;
     private retryFailedTurnAsync;
     private isActiveRuntimeSession;
     addCustomMessageEntry(message: Record<string, unknown>): void;

package/dist/app/session/session-event-controller.js

@@ -1,3 +1,4 @@
+import { isRetryableAssistantError } from "@earendil-works/pi-ai";
 import { createId } from "../id.js";
 import { extractImageContents, renderContent, renderUserMessageContent, stringifyUnknown } from "../rendering/message-content.js";
 import { customMessageEntry, extensionSessionEntry, loadSessionHistoryEntries, loadSessionHistoryEntriesAsync } from "./session-history.js";
@@ -351,6 +352,25 @@ export class AppSessionEventController {
     retryFailedTurn(session) {
         void this.retryFailedTurnAsync(session);
     }
+    /**
+     * The SDK only emits `auto_retry_end` (whose toast carries the Retry button)
+     * when auto-retry actually runs. When retry is disabled, a transient streaming
+     * error such as a 429 rate limit surfaces only as the error entry above, with
+     * no way to resume the failed turn. Offer a manual Retry toast in that case,
+     * mirroring the auto-retry path. User aborts and non-retryable errors are
+     * excluded, and retry being enabled means the auto-retry toast will handle it.
+     */
+    showManualRetryOnTerminalError(error) {
+        const errorText = error.errorMessage;
+        if (!errorText || !isRetryableAssistantError(error))
+            return;
+        const session = this.host.runtime()?.session;
+        if (!session || session.autoRetryEnabled)
+            return;
+        this.host.showToast(`Request failed: ${errorText}`, "error", {
+            action: { label: "Retry", onSelect: () => this.retryFailedTurn(session) },
+        });
+    }
     async retryFailedTurnAsync(session) {
         const runtime = this.host.runtime();
         if (!runtime || !this.isActiveRuntimeSession(runtime, session))
@@ -693,12 +713,15 @@ export class AppSessionEventController {
                 this.assistantMessageClosed = true;
                 this.host.setSessionActivity(this.host.runtime()?.session.isStreaming ? "running" : "idle");
                 break;
-            case "error":
+            case "error": {
                 this.finishCurrentThinkingEntry();
                 this.flushAssistantTextBuffer(true);
                 this.host.setSessionActivity(this.host.runtime()?.session.isStreaming ? "running" : "idle");
-                this.addEntry({ id: createId("error"), kind: "error", text: assistantEvent.error.errorMessage ?? assistantEvent.reason });
+                const errorText = assistantEvent.error.errorMessage ?? assistantEvent.reason;
+                this.addEntry({ id: createId("error"), kind: "error", text: errorText });
+                this.showManualRetryOnTerminalError(assistantEvent.error);
                 break;
+            }
             default:
                 break;
         }

package/dist/schemas/pi-tools-suite-schema.d.ts

@@ -9,6 +9,8 @@ export declare const PiToolsSuiteConfigSchema: Type.TObject<{
     $schema: Type.TOptional<Type.TString>;
     enabled: Type.TOptional<Type.TBoolean>;
     disabledModules: Type.TOptional<Type.TArray<Type.TString>>;
+    enabledModules: Type.TOptional<Type.TArray<Type.TString>>;
+    modules: Type.TOptional<Type.TRecord<"^.*$", Type.TBoolean>>;
     todoThinking: Type.TOptional<Type.TBoolean>;
     lookupModel: Type.TOptional<Type.TUnion<[Type.TString, Type.TNull]>>;
     terminalBell: Type.TOptional<Type.TObject<{
@@ -163,6 +165,10 @@ export declare const PiToolsSuiteConfigSchema: Type.TObject<{
             prompt: Type.TString;
         }>>>;
     }>>;
+    secretFirewall: Type.TOptional<Type.TObject<{
+        sessionHygiene: Type.TOptional<Type.TBoolean>;
+        notify: Type.TOptional<Type.TBoolean>;
+    }>>;
     lsp: Type.TOptional<Type.TObject<{
         servers: Type.TOptional<Type.TArray<Type.TObject<{
             id: Type.TString;

package/dist/schemas/pi-tools-suite-schema.js

@@ -181,6 +181,10 @@ const PromptCommand = Type.Object({
 const PromptCommandsConfig = Type.Object({
     commands: Type.Optional(Type.Record(Type.String(), PromptCommand, { description: "Command definitions keyed by slash command name." })),
 }, { description: "User-defined slash commands." });
+const SecretFirewallConfig = Type.Object({
+    sessionHygiene: Type.Optional(Type.Boolean({ description: "Redact detected secret material from tool results and completed messages before it remains in session history." })),
+    notify: Type.Optional(Type.Boolean({ description: "Show a warning when one or more secrets are redacted. Secret values are never included in notifications." })),
+}, { description: "Settings for the opt-in credential-firewall module." });
 // ---------------------------------------------------------------------------
 // LSP
 // ---------------------------------------------------------------------------
@@ -214,6 +218,8 @@ export const PiToolsSuiteConfigSchema = Type.Object({
     $schema: Type.Optional(Type.String({ description: "JSON Schema URL used by editors for validation and autocomplete." })),
     enabled: Type.Optional(Type.Boolean({ description: "Enable or disable the entire pi-tools-suite extension." })),
     disabledModules: Type.Optional(Type.Array(Type.String(), { description: "List of disabled module names (e.g. ['lsp', 'prompt-commands'])." })),
+    enabledModules: Type.Optional(Type.Array(Type.String(), { description: "List of module names to explicitly enable, including modules that are disabled by default." })),
+    modules: Type.Optional(Type.Record(Type.String(), Type.Boolean(), { description: "Per-module enable/disable map. credential-firewall is disabled by default and can be enabled here." })),
     todoThinking: Type.Optional(Type.Boolean({ description: "Enable per-todo thinking levels and automatic thinking switch/restore when tasks become in-progress/completed." })),
     lookupModel: Type.Optional(Type.Union([Type.String(), Type.Null()], { description: "Vision-capable provider/model used by GLM's lookup tool; unset or null disables lookup." })),
     terminalBell: Type.Optional(TerminalBellConfig),
@@ -221,6 +227,7 @@ export const PiToolsSuiteConfigSchema = Type.Object({
     asyncSubagents: Type.Optional(AsyncSubagentsConfig),
     toolRenderer: Type.Optional(ToolRendererConfig),
     promptCommands: Type.Optional(PromptCommandsConfig),
+    secretFirewall: Type.Optional(SecretFirewallConfig),
     lsp: Type.Optional(LspConfig),
 }, {
     $id: "https://unpkg.com/pi-ui-extend/schemas/pi-tools-suite.json",

package/external/pi-tools-suite/README.md

@@ -5,6 +5,7 @@ Local all-in-one Pi extension package.
 This package keeps shared Pi tools as ordinary source folders under `src/` and registers them through one entrypoint.
 
 - `src/coding-discipline` — injects a deduplicated silent-mode and quality-discipline block at the very top of the main-session per-turn system prompt for GLM main-session models only (`isGlmModel`) immediately before the LLM request; non-GLM models are left untouched; disabled for async sub-agents
+- `src/credential-firewall` — opt-in secret firewall for high-confidence outbound/session credential redaction; disabled by default
 - `src/ast-grep` — `ast_grep` / `ast_apply`
 - `src/async-subagents` — `subagents` tool and sub-agent slash commands, including oh-my-openagent-style `/ultrawork` (`/ulw`) and `/hyperplan` orchestration prompts, plus config-defined sub-agent model/thinking/args presets selected via `/subagent-preset` from `asyncSubagents` in `~/.config/pi/pi-tools-suite.jsonc`; includes the `frontend` profile for Gemini-friendly UI/UX and visual frontend work and the `oracle` profile for cross-provider second opinions; enforces a 30-minute per-agent execution timeout, project-wide `maxConcurrent` queueing, optional retry/backoff, and `result.json` structured metadata/chaining fields next to raw `result.md`; stores project-local run files and a registry under `.pi/subagents/` so result/status collection can recover after compaction or reload while the main session remains alive
 - `src/lsp` — shared LSP diagnostics hook/library that enriches mutating tool results with diagnostics and shuts down language servers on session shutdown
@@ -23,7 +24,7 @@ This package keeps shared Pi tools as ordinary source folders under `src/` and r
 
 `index.ts` is intentionally only a thin auto-discovery shim that re-exports `src/index.ts`. There is no `pi.extensions` manifest here, so local Pi auto-discovery loads the suite once via `~/.pi/agent/extensions/pi-tools-suite/index.ts` and does not double-register tools.
 
-Registration order is preserved in `src/index.ts`: coding-discipline, ast-grep, async-subagents, lsp, comment-checker, session-name, repo-discovery command/tool gate, antigravity-auth provider, OpenCode import, todo, model-tools, usage, web-search, dcp, prompt-commands, then skill-installer. Tool metadata and active model-specific tool sets have two modes: standard and repo-aware. When `.indexer-cli` enables `repo_*`, those tools stay active ahead of overlapping lower-level aliases so the indexed discovery surface has priority.
+Registration order is preserved in `src/index.ts`: coding-discipline, ast-grep, async-subagents, lsp, comment-checker, session-name, repo-discovery command/tool gate, antigravity-auth provider, OpenCode import, todo, model-tools, usage, web-search, dcp, prompt-commands, skill-installer, credential-firewall, then codex-reasoning-fix. Tool metadata and active model-specific tool sets have two modes: standard and repo-aware. When `.indexer-cli` enables `repo_*`, those tools stay active ahead of overlapping lower-level aliases so the indexed discovery surface has priority.
 
 ## Disabling modules
 
@@ -44,6 +45,8 @@ PI_TOOLS_SUITE_DISABLED=1 pi ...   # disables all pi-tools-suite modules
 
 `disabledExtensions`, `enabledModules`, `enabledExtensions`, and an `extensions` map are accepted as aliases for the same module names. Use `*` or `all` in `PI_TOOLS_SUITE_DISABLED_MODULES` to skip every registered module.
 
+`credential-firewall` is disabled by default. Enable it explicitly with `"modules": { "credential-firewall": true }`. When enabled it replaces high-confidence secret material in the final provider payload with stable placeholders such as `<SECRET:github_token:1>`. `secretFirewall.sessionHygiene` (default `true`) applies the same redactor to tool results and completed messages before they remain in session history; `secretFirewall.notify` controls warnings. Entropy-only detection is intentionally not used yet to avoid corrupting hashes, IDs, minified assets, and other high-entropy non-secrets.
+
 Saved prompt slash commands are stored under `promptCommands`. Use `/prompt-commands` to create, edit, rename, delete, list, show the config path, or run them from an interactive menu. After a CRUD edit the module reloads Pi resources so the slash-command list reflects the config. Each saved command sends its saved prompt as a user message.
 
 ```jsonc

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

@@ -49,6 +49,16 @@ const SILENCE_REMINDER_MIN_MESSAGE_GAP = 20;
 // 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(
 	{
@@ -203,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));
 	});
@@ -222,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) => {
@@ -350,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;
 

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

@@ -41,7 +41,7 @@ const FALSE_VALUES = new Set(["0", "false", "off", "no"]);
 const DISABLED_LIST_KEYS = ["disabledModules", "disabledExtensions"];
 const ENABLED_LIST_KEYS = ["enabledModules", "enabledExtensions"];
 const MODULE_MAP_KEYS = ["modules", "extensions"];
-const DEFAULT_DISABLED_MODULES = new Set<string>();
+const DEFAULT_DISABLED_MODULES = new Set<string>(["credential-firewall"]);
 
 export function getPiToolsSuiteUserConfigPath(homeDir = homedir()): string {
 	return join(homeDir, ".config", "pi", "pi-tools-suite.jsonc");

package/external/pi-tools-suite/src/credential-firewall/config.ts

@@ -0,0 +1,77 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, parse, resolve } from "node:path";
+import { parse as parseJsonc } from "jsonc-parser";
+
+import { getPiToolsSuiteUserConfigPath } from "../config.js";
+
+export interface SecretFirewallConfig {
+	sessionHygiene: boolean;
+	notify: boolean;
+}
+
+const TRUE_VALUES = new Set(["1", "true", "on", "yes"]);
+const FALSE_VALUES = new Set(["0", "false", "off", "no"]);
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function readJsonc(filePath: string): Record<string, unknown> {
+	if (!existsSync(filePath)) return {};
+	try {
+		const parsed = parseJsonc(readFileSync(filePath, "utf8"));
+		return isRecord(parsed) ? parsed : {};
+	} catch {
+		return {};
+	}
+}
+
+function findProjectConfig(startDir: string): string | undefined {
+	let dir = resolve(startDir);
+	const root = parse(dir).root;
+	while (true) {
+		const candidate = join(dir, ".pi", "pi-tools-suite.jsonc");
+		if (existsSync(candidate)) return candidate;
+		if (dir === root) return undefined;
+		const parent = dirname(dir);
+		if (parent === dir) return undefined;
+		dir = parent;
+	}
+}
+
+function boolFromEnv(value: string | undefined): boolean | undefined {
+	if (value === undefined) return undefined;
+	const normalized = value.trim().toLowerCase();
+	if (TRUE_VALUES.has(normalized)) return true;
+	if (FALSE_VALUES.has(normalized)) return false;
+	return undefined;
+}
+
+export function loadSecretFirewallConfig(
+	cwd: string = process.cwd(),
+	env: NodeJS.ProcessEnv = process.env,
+	homeDir: string = env.HOME ?? process.env.HOME ?? "",
+): SecretFirewallConfig {
+	let sessionHygiene = true;
+	let notify = true;
+
+	const layers = [getPiToolsSuiteUserConfigPath(homeDir)];
+	if (env.PI_CONFIG_DIR) layers.push(join(env.PI_CONFIG_DIR, "pi-tools-suite.jsonc"));
+	const projectConfig = findProjectConfig(cwd);
+	if (projectConfig) layers.push(projectConfig);
+
+	for (const filePath of layers) {
+		const root = readJsonc(filePath);
+		const section = root.secretFirewall;
+		if (!isRecord(section)) continue;
+		if (typeof section.sessionHygiene === "boolean") sessionHygiene = section.sessionHygiene;
+		if (typeof section.notify === "boolean") notify = section.notify;
+	}
+
+	const envSessionHygiene = boolFromEnv(env.PI_SECRET_FIREWALL_SESSION_HYGIENE);
+	if (envSessionHygiene !== undefined) sessionHygiene = envSessionHygiene;
+	const envNotify = boolFromEnv(env.PI_SECRET_FIREWALL_NOTIFY);
+	if (envNotify !== undefined) notify = envNotify;
+
+	return { sessionHygiene, notify };
+}

package/external/pi-tools-suite/src/credential-firewall/index.ts

@@ -0,0 +1,62 @@
+import { loadSecretFirewallConfig } from "./config.js";
+import { SecretRedactor, type SecretKind, type SecretRedactionResult, type SecretRedactionSummary } from "./redact.js";
+
+type ExtensionAPI = any;
+type ExtensionContext = {
+	cwd?: string;
+	ui?: { notify?: (message: string, type?: "info" | "warning" | "error") => void };
+};
+
+function maybeNotify(ctx: ExtensionContext, result: SecretRedactionSummary, source: string, enabled: boolean): void {
+	if (!enabled || result.count === 0) return;
+	try {
+		ctx.ui?.notify?.(
+			`Secret firewall redacted ${result.count} secret${result.count === 1 ? "" : "s"} from ${source}: ${result.kinds.join(", ")}.`,
+			"warning",
+		);
+	} catch {
+		// Protection must not fail because a headless or stale UI cannot notify.
+	}
+}
+
+export default function credentialFirewall(pi: ExtensionAPI): void {
+	const redactor = new SecretRedactor();
+
+	pi.on("before_provider_request", async (event: { payload?: unknown }, ctx: ExtensionContext) => {
+		const config = loadSecretFirewallConfig(ctx.cwd ?? process.cwd());
+		const result = redactor.redact(event.payload);
+		if (result.count === 0) return undefined;
+		maybeNotify(ctx, result, "provider payload", config.notify);
+		return result.value;
+	});
+
+	pi.on("tool_result", async (event: { content?: unknown; details?: unknown }, ctx: ExtensionContext) => {
+		const config = loadSecretFirewallConfig(ctx.cwd ?? process.cwd());
+		if (!config.sessionHygiene) return undefined;
+
+		const content = redactor.redact(event.content);
+		const details = redactor.redact(event.details);
+		const count = content.count + details.count;
+		if (count === 0) return undefined;
+		const kinds = [...new Set([...content.kinds, ...details.kinds])] as SecretKind[];
+		maybeNotify(ctx, { count, kinds }, "tool result", config.notify);
+		return {
+			...(content.count > 0 ? { content: content.value } : {}),
+			...(details.count > 0 ? { details: details.value } : {}),
+		};
+	});
+
+	pi.on("message_end", async (event: { message?: unknown }, ctx: ExtensionContext) => {
+		const config = loadSecretFirewallConfig(ctx.cwd ?? process.cwd());
+		if (!config.sessionHygiene || !event.message) return undefined;
+		const result = redactor.redact(event.message);
+		if (result.count === 0) return undefined;
+		maybeNotify(ctx, result, "session message", config.notify);
+		return { message: result.value };
+	});
+}
+
+export { loadSecretFirewallConfig } from "./config.js";
+export { SecretRedactor } from "./redact.js";
+export type { SecretFirewallConfig } from "./config.js";
+export type { SecretKind, SecretRedactionResult, SecretRedactionSummary } from "./redact.js";

package/external/pi-tools-suite/src/credential-firewall/redact.ts

@@ -0,0 +1,222 @@
+import { createHash } from "node:crypto";
+
+export type SecretKind =
+	| "private_key"
+	| "github_token"
+	| "gitlab_token"
+	| "api_key"
+	| "google_api_key"
+	| "aws_access_key"
+	| "slack_token"
+	| "stripe_key"
+	| "npm_token"
+	| "pypi_token"
+	| "telegram_bot_token"
+	| "bearer_token"
+	| "basic_auth"
+	| "password"
+	| "credential";
+
+export interface SecretRedactionSummary {
+	count: number;
+	kinds: SecretKind[];
+}
+
+export interface SecretRedactionResult<T = unknown> extends SecretRedactionSummary {
+	value: T;
+}
+
+type MatchPattern = { kind: SecretKind; pattern: RegExp };
+
+const EXACT_SECRET_PATTERNS: MatchPattern[] = [
+	{ kind: "private_key", pattern: /-----BEGIN ([A-Z0-9 ]*PRIVATE KEY)-----[\s\S]*?-----END \1-----/g },
+	{ kind: "github_token", pattern: /\b(?:gh[pousr]_[A-Za-z0-9]{20,255}|github_pat_[A-Za-z0-9_]{20,255})\b/g },
+	{ kind: "gitlab_token", pattern: /\bglpat-[A-Za-z0-9_-]{20,255}\b/g },
+	{ kind: "api_key", pattern: /\bsk-(?:ant-|proj-)?[A-Za-z0-9_-]{24,255}\b/g },
+	{ kind: "google_api_key", pattern: /\bAIza[0-9A-Za-z_-]{35}\b/g },
+	{ kind: "aws_access_key", pattern: /\b(?:AKIA|ASIA)[A-Z0-9]{16}\b/g },
+	{ kind: "slack_token", pattern: /\bxox[baprs]-[A-Za-z0-9-]{20,255}\b/g },
+	{ kind: "stripe_key", pattern: /\b(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{16,255}\b/g },
+	{ kind: "npm_token", pattern: /\bnpm_[A-Za-z0-9]{30,255}\b/g },
+	{ kind: "pypi_token", pattern: /\bpypi-[A-Za-z0-9_-]{40,255}\b/g },
+	{ kind: "telegram_bot_token", pattern: /\b\d{8,12}:[A-Za-z0-9_-]{30,}\b/g },
+];
+
+const SENSITIVE_ASSIGNMENT = /((?:["']?)(?:api[_-]?key|secret(?:[_-]?key)?|client[_-]?secret|access[_-]?token|refresh[_-]?token|auth[_-]?token|password|passwd|pwd|private[_-]?key|npm[_-]?token|github[_-]?token|gitlab[_-]?token|aws[_-]?access[_-]?key[_-]?id|aws[_-]?secret[_-]?access[_-]?key|aws[_-]?session[_-]?token)(?:["']?)\s*[:=]\s*)(["']?)([^\s"',}{;]{8,})(["']?)/gi;
+const BEARER_AUTH = /(\bAuthorization\s*:\s*Bearer\s+)([A-Za-z0-9._~+\/=:-]{12,})/gi;
+const BASIC_AUTH = /(\bAuthorization\s*:\s*Basic\s+)([A-Za-z0-9+/=]{8,})/gi;
+const URL_PASSWORD = /(\b[a-z][a-z0-9+.-]*:\/\/[^:\s/@]+:)([^@\s/]{4,})(@)/gi;
+
+const SAFE_EXACT_VALUES = new Set([
+	"[redacted]",
+	"redacted",
+	"placeholder",
+	"changeme",
+	"change-me",
+	"not-a-secret",
+	"not_secret",
+	"example",
+	"dummy",
+	"replace_me",
+	"replace-me",
+]);
+
+function shouldSkipCandidate(value: string): boolean {
+	const normalized = value.trim().toLowerCase();
+	if (!normalized) return true;
+	if (normalized.includes("<secret:")) return true;
+	if (normalized.startsWith("$") || normalized.startsWith("${") || normalized.startsWith("{{")) return true;
+	if (normalized.startsWith("process.env") || normalized.startsWith("env.")) return true;
+	if (/^\*+$/.test(normalized) || /^x+$/.test(normalized)) return true;
+	if (/^your[_-][a-z0-9_-]+$/i.test(normalized)) return true;
+	return SAFE_EXACT_VALUES.has(normalized);
+}
+
+function kindForAssignmentPrefix(prefix: string): SecretKind {
+	const normalized = prefix.toLowerCase();
+	if (normalized.includes("password") || normalized.includes("passwd") || /\bpwd\b/.test(normalized)) return "password";
+	if (normalized.includes("api") && normalized.includes("key")) return "api_key";
+	if (normalized.includes("aws") && normalized.includes("access") && normalized.includes("key")) return "aws_access_key";
+	if (normalized.includes("private") && normalized.includes("key")) return "private_key";
+	return "credential";
+}
+
+function kindForSensitiveKey(key: string): SecretKind | undefined {
+	const normalized = key.toLowerCase().replace(/[^a-z0-9]+/g, "_");
+	if (normalized === "password" || normalized === "passwd" || normalized === "pwd") return "password";
+	if (normalized.includes("private_key")) return "private_key";
+	if (normalized.includes("api_key")) return "api_key";
+	if (normalized === "aws_access_key_id") return "aws_access_key";
+	if (
+		normalized.includes("secret") ||
+		normalized.includes("token") ||
+		normalized === "authorization" ||
+		normalized === "credential" ||
+		normalized === "credentials"
+	) return "credential";
+	return undefined;
+}
+
+function uniqueKinds(kinds: SecretKind[]): SecretKind[] {
+	return [...new Set(kinds)];
+}
+
+function isPlainRecord(value: unknown): value is Record<string, unknown> {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+
+function shouldSkipOpaqueField(parent: Record<string, unknown>, key: string): boolean {
+	if (key === "encrypted_content" || key === "signature") return true;
+	return key === "data" && (parent.type === "image" || parent.type === "input_image" || parent.type === "image_url");
+}
+
+export class SecretRedactor {
+	// Keep only a one-way digest for stable placeholders; never retain plaintext
+	// secret material merely to correlate repeated redactions.
+	private readonly placeholders = new Map<string, string>();
+	private readonly counters = new Map<SecretKind, number>();
+
+	private placeholder(secret: string, kind: SecretKind): string {
+		const fingerprint = createHash("sha256").update(secret).digest("hex");
+		const existing = this.placeholders.get(fingerprint);
+		if (existing) return existing;
+		const next = (this.counters.get(kind) ?? 0) + 1;
+		this.counters.set(kind, next);
+		const placeholder = `<SECRET:${kind}:${next}>`;
+		this.placeholders.set(fingerprint, placeholder);
+		return placeholder;
+	}
+
+	redactString(input: string): SecretRedactionResult<string> {
+		let value = input;
+		let count = 0;
+		const kinds: SecretKind[] = [];
+
+		const replaceSecret = (secret: string, kind: SecretKind): string => {
+			if (shouldSkipCandidate(secret)) return secret;
+			count++;
+			kinds.push(kind);
+			return this.placeholder(secret, kind);
+		};
+
+		SENSITIVE_ASSIGNMENT.lastIndex = 0;
+		value = value.replace(SENSITIVE_ASSIGNMENT, (match, prefix: string, openingQuote: string, secret: string, closingQuote: string) => {
+			if (openingQuote && closingQuote && openingQuote !== closingQuote) return match;
+			const replacement = replaceSecret(secret, kindForAssignmentPrefix(prefix));
+			return `${prefix}${openingQuote}${replacement}${closingQuote}`;
+		});
+
+		BEARER_AUTH.lastIndex = 0;
+		value = value.replace(BEARER_AUTH, (_match, prefix: string, secret: string) => `${prefix}${replaceSecret(secret, "bearer_token")}`);
+
+		BASIC_AUTH.lastIndex = 0;
+		value = value.replace(BASIC_AUTH, (_match, prefix: string, secret: string) => `${prefix}${replaceSecret(secret, "basic_auth")}`);
+
+		URL_PASSWORD.lastIndex = 0;
+		value = value.replace(URL_PASSWORD, (_match, prefix: string, secret: string, suffix: string) => `${prefix}${replaceSecret(secret, "password")}${suffix}`);
+
+		// Exact token formats run last so placeholders introduced by contextual
+		// detectors are never reinterpreted as new secret assignments.
+		for (const { kind, pattern } of EXACT_SECRET_PATTERNS) {
+			pattern.lastIndex = 0;
+			value = value.replace(pattern, (secret) => replaceSecret(secret, kind));
+		}
+
+		return { value, count, kinds: uniqueKinds(kinds) };
+	}
+
+	redact<T>(input: T): SecretRedactionResult<T> {
+		const result = this.redactValue(input);
+		return { value: result.value as T, count: result.count, kinds: uniqueKinds(result.kinds) };
+	}
+
+	private redactValue(input: unknown): SecretRedactionResult {
+		if (typeof input === "string") return this.redactString(input);
+		if (Array.isArray(input)) {
+			let changed = false;
+			let count = 0;
+			const kinds: SecretKind[] = [];
+			const next = input.map((item) => {
+				const result = this.redactValue(item);
+				if (result.value !== item) changed = true;
+				count += result.count;
+				kinds.push(...result.kinds);
+				return result.value;
+			});
+			return { value: changed ? next : input, count, kinds };
+		}
+		if (!isPlainRecord(input)) return { value: input, count: 0, kinds: [] };
+
+		let changed = false;
+		let count = 0;
+		const kinds: SecretKind[] = [];
+		const next: Record<string, unknown> = {};
+		for (const [key, item] of Object.entries(input)) {
+			if (typeof item === "string" && shouldSkipOpaqueField(input, key)) {
+				next[key] = item;
+				continue;
+			}
+			if (typeof item === "string") {
+				const keyKind = kindForSensitiveKey(key);
+				if (keyKind && !shouldSkipCandidate(item)) {
+					const replacement = this.placeholder(item, keyKind);
+					next[key] = replacement;
+					if (replacement !== item) {
+						changed = true;
+						count++;
+						kinds.push(keyKind);
+					}
+					continue;
+				}
+			}
+			const result = this.redactValue(item);
+			next[key] = result.value;
+			if (result.value !== item) changed = true;
+			count += result.count;
+			kinds.push(...result.kinds);
+		}
+		return { value: changed ? next : input, count, kinds };
+	}
+}

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

@@ -5,6 +5,13 @@ export const DEFAULT_PI_TOOLS_SUITE_CONFIG_JSONC = String.raw`{
     // "ast-grep",
     // "dcp"
   ],
+  // Secret firewall is deliberately opt-in for now. Flip this to true to enable
+  // high-confidence outbound redaction plus session-history hygiene.
+  "modules": { "credential-firewall": false },
+  "secretFirewall": {
+    "sessionHygiene": true,
+    "notify": true
+  },
   // When true, todo items may carry a per-task thinking level and the todo
   // module will switch/restore Pi's thinking level as in-progress tasks change.
   "todoThinking": true,

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

@@ -26,6 +26,8 @@ export const MODULES: Array<{ name: string; load: () => Promise<ExtensionModule>
 	{ name: "dcp", load: () => import("./dcp/index") },
 	{ name: "prompt-commands", load: () => import("./prompt-commands/index") },
 	{ name: "skill-installer", load: () => import("./skill-installer/index") },
+	// Secret firewall is intentionally opt-in. Keep it after payload-shaping modules.
+	{ name: "credential-firewall", load: () => import("./credential-firewall/index") },
 	// Keep this last: its before_provider_request handler is the final payload
 	// sanitizer after DCP and any other provider-payload modifiers.
 	{ name: "codex-reasoning-fix", load: () => import("./codex-reasoning-fix/index") },

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.12",
+  "version": "1.0.14",
   "description": "Pix: a workspace-first terminal UI for Pi with tabs, readable tool activity, voice input, and bundled agent tools.",
   "private": false,
   "repository": {

package/schemas/pi-tools-suite.json

@@ -16,6 +16,22 @@
       },
       "description": "List of disabled module names (e.g. ['lsp', 'prompt-commands'])."
     },
+    "enabledModules": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "List of module names to explicitly enable, including modules that are disabled by default."
+    },
+    "modules": {
+      "type": "object",
+      "patternProperties": {
+        "^.*$": {
+          "type": "boolean"
+        }
+      },
+      "description": "Per-module enable/disable map. credential-firewall is disabled by default and can be enabled here."
+    },
     "todoThinking": {
       "type": "boolean",
       "description": "Enable per-todo thinking levels and automatic thinking switch/restore when tasks become in-progress/completed."
@@ -812,6 +828,20 @@
       },
       "description": "User-defined slash commands."
     },
+    "secretFirewall": {
+      "type": "object",
+      "properties": {
+        "sessionHygiene": {
+          "type": "boolean",
+          "description": "Redact detected secret material from tool results and completed messages before it remains in session history."
+        },
+        "notify": {
+          "type": "boolean",
+          "description": "Show a warning when one or more secrets are redacted. Secret values are never included in notifications."
+        }
+      },
+      "description": "Settings for the opt-in credential-firewall module."
+    },
     "lsp": {
       "type": "object",
       "properties": {