@herbertgao/pi-extensions 2026.8.11 → 2026.8.13

package/node_modules/@czottmann/pi-automode/extensions/auto-mode/permissions.ts

@@ -1,7 +1,14 @@
+import {
+  analyzeBash,
+  type BashAnalysis,
+  type BashCommandAnalysis,
+  type BashRedirectAnalysis,
+} from "./bash.ts";
 import type { ToolPattern } from "./types.ts";
 import {
   expandHomePattern,
   normalizePathForMatch,
+  resolveInputPath,
   resolvePathForPolicy,
   resolveToolInputPath,
 } from "./paths.ts";
@@ -9,6 +16,8 @@ import {
 export const MAX_WILDCARD_PATTERN_LENGTH = 4096;
 export const MAX_WILDCARD_INPUT_LENGTH = 1024 * 1024;
 
+const bashPatternAnalyses = new WeakMap<ToolPattern, BashAnalysis>();
+
 /** Preserve the previous non-Unicode RegExp `/i` case-equivalence rules. */
 function canonicalizeCase(value: string): string {
   let canonical = "";
@@ -55,11 +64,14 @@ export function parseToolPattern(value: unknown): ToolPattern | undefined {
 
   const match = raw.match(/^@?([A-Za-z0-9_-]+)(?:\((.*)\))?$/s);
   if (!match) return { raw };
-  return {
-    raw,
-    toolName: normalizeToolName(match[1] ?? ""),
-    argumentPattern: match[2],
-  };
+  const toolName = normalizeToolName(match[1] ?? "");
+  const argumentPattern = match[2];
+  const bashPatternAnalysis = toolName === "bash" && argumentPattern
+    ? analyzeBash(argumentPattern)
+    : undefined;
+  const pattern: ToolPattern = { raw, toolName, argumentPattern };
+  if (bashPatternAnalysis) bashPatternAnalyses.set(pattern, bashPatternAnalysis);
+  return pattern;
 }
 
 function literalPrefixTable(value: string): number[] {
@@ -166,36 +178,110 @@ export function matchesWildcardPattern(
   return true;
 }
 
-function getPrimaryArgument(
+export function normalizePermissionPathForMatch(
+  path: string,
+  platform: NodeJS.Platform = process.platform,
+): string {
+  return platform === "win32" ? path.replace(/\\/g, "/") : path;
+}
+
+function pathArgumentsForMatch(
+  toolName: string,
+  cwd: string,
+  value: string,
+  overflowPolicy: WildcardOverflowPolicy,
+): string[] {
+  const resolved = resolveToolInputPath(toolName, cwd, value) ?? value;
+  const canonical = resolvePathForPolicy(resolved);
+  const candidates = canonical
+    ? [canonical, normalizePathForMatch(canonical, cwd)]
+    : [];
+  if (overflowPolicy === "match") {
+    candidates.push(resolved, normalizePathForMatch(resolved, cwd));
+  }
+  return [...new Set(
+    candidates.map((candidate) => normalizePermissionPathForMatch(candidate)),
+  )];
+}
+
+function getPrimaryArguments(
   toolName: string,
   input: Record<string, unknown>,
   cwd: string,
-): string {
+  overflowPolicy: WildcardOverflowPolicy,
+): string[] {
   if (toolName === "bash" && typeof input.command === "string") {
-    return input.command;
+    return [input.command];
   }
   if (
     (toolName === "read" || toolName === "write" || toolName === "edit") &&
     typeof input.path === "string"
   ) {
-    return normalizePathForMatch(
-      resolveToolInputPath(toolName, cwd, input.path) ?? input.path,
-      cwd,
-    );
+    return pathArgumentsForMatch(toolName, cwd, input.path, overflowPolicy);
   }
   if (toolName === "grep" && typeof input.pattern === "string") {
-    return input.pattern;
+    return [input.pattern];
   }
   if (
     (toolName === "find" || toolName === "ls") &&
     typeof input.path === "string"
   ) {
-    return normalizePathForMatch(
-      resolveToolInputPath(toolName, cwd, input.path) ?? input.path,
-      cwd,
-    );
+    return pathArgumentsForMatch(toolName, cwd, input.path, overflowPolicy);
   }
-  return JSON.stringify(input);
+  return [JSON.stringify(input)];
+}
+
+function isPermissionPathTool(toolName: string): boolean {
+  return toolName === "read" ||
+    toolName === "write" ||
+    toolName === "edit" ||
+    toolName === "find" ||
+    toolName === "ls";
+}
+
+export function appendPermissionPathPatternSuffix(
+  scope: string,
+  suffix: string,
+): string {
+  const normalizedScope = withoutTrailingSlash(
+    normalizePermissionPathForMatch(scope),
+  );
+  return normalizedScope.endsWith("/")
+    ? `${normalizedScope}${suffix}`
+    : `${normalizedScope}/${suffix}`;
+}
+
+function permissionPathPatternVariants(
+  pattern: string,
+  cwd: string,
+): string[] {
+  const expanded = normalizePermissionPathForMatch(expandHomePattern(pattern));
+  const wildcardIndex = expanded.indexOf("*");
+  if (wildcardIndex === -1) {
+    const resolved = resolveInputPath(cwd, expanded);
+    const canonical = resolved ? resolvePathForPolicy(resolved) : undefined;
+    return [...new Set(
+      [expanded, resolved, canonical]
+        .filter((value): value is string => !!value)
+        .map((value) => normalizePermissionPathForMatch(value)),
+    )];
+  }
+
+  const fixedPrefix = expanded.slice(0, wildcardIndex);
+  const lastSlash = fixedPrefix.lastIndexOf("/");
+  if (lastSlash < 0) return [expanded];
+  const fixedScope = fixedPrefix.slice(0, lastSlash) || "/";
+  const resolvedScope = resolveInputPath(cwd, fixedScope);
+  if (!resolvedScope) return [expanded];
+  const canonicalScope = resolvePathForPolicy(resolvedScope);
+  const suffix = expanded.slice(lastSlash).replace(/^\/+/, "");
+  return [...new Set([
+    expanded,
+    appendPermissionPathPatternSuffix(resolvedScope, suffix),
+    ...(canonicalScope
+      ? [appendPermissionPathPatternSuffix(canonicalScope, suffix)]
+      : []),
+  ])];
 }
 
 /**
@@ -285,6 +371,37 @@ export function recursiveSearchMayReachDeniedPath(
   });
 }
 
+function normalizedBashArgumentPattern(pattern: ToolPattern): string {
+  const patternAnalysis = bashPatternAnalyses.get(pattern);
+  if (
+    patternAnalysis &&
+    patternAnalysis.errors.length === 0 &&
+    patternAnalysis.redirects.length === 0 &&
+    isStructurallyPlainSingleCommand(patternAnalysis)
+  ) {
+    return patternAnalysis.commands[0]?.text ?? pattern.argumentPattern ?? "";
+  }
+  return pattern.argumentPattern ?? "";
+}
+
+function matchesBashArgumentPattern(
+  argumentPattern: string,
+  candidate: string,
+  overflowPolicy: WildcardOverflowPolicy,
+): boolean {
+  if (matchesWildcardPattern(argumentPattern, candidate, overflowPolicy)) {
+    return true;
+  }
+  if (overflowPolicy !== "match" || !argumentPattern.endsWith(" *")) {
+    return false;
+  }
+  return matchesWildcardPattern(
+    argumentPattern.slice(0, -2),
+    candidate,
+    overflowPolicy,
+  );
+}
+
 /** Match a scoped permission rule against a concrete tool call. */
 export function matchesToolPattern(
   pattern: ToolPattern,
@@ -292,10 +409,215 @@ export function matchesToolPattern(
   input: Record<string, unknown>,
   cwd: string,
   overflowPolicy: WildcardOverflowPolicy = "match",
+  bashAnalysis?: BashAnalysis,
 ): boolean {
-  if (!pattern.toolName) return false;
+  if (!pattern.toolName) return overflowPolicy === "match";
   if (pattern.toolName !== normalizeToolName(toolName)) return false;
-  if (!pattern.argumentPattern) return true;
-  const primary = getPrimaryArgument(toolName, input, cwd);
-  return matchesWildcardPattern(pattern.argumentPattern, primary, overflowPolicy);
+  if (pattern.argumentPattern === undefined) return true;
+  if (pattern.argumentPattern.trim() === "") {
+    return overflowPolicy === "match";
+  }
+  if (
+    toolName === "bash" &&
+    (bashPatternAnalyses.get(pattern)?.errors.length ?? 0) > 0
+  ) {
+    return overflowPolicy === "match";
+  }
+  if (toolName === "bash" && bashAnalysis) {
+    if (bashAnalysis.errors.length > 0) return overflowPolicy === "match";
+    const candidates = overflowPolicy === "match"
+      ? [bashAnalysis.source, ...bashAnalysis.commands.map((command) => command.text)]
+      : [bashAnalysis.source];
+    const argumentPattern = normalizedBashArgumentPattern(pattern);
+    return candidates.some((candidate) =>
+      matchesBashArgumentPattern(argumentPattern, candidate, overflowPolicy)
+    );
+  }
+  const argumentPatterns = isPermissionPathTool(toolName)
+    ? permissionPathPatternVariants(pattern.argumentPattern, cwd)
+    : [pattern.argumentPattern];
+  const primaryArguments = getPrimaryArguments(
+    toolName,
+    input,
+    cwd,
+    overflowPolicy,
+  );
+  return argumentPatterns.some((argumentPattern) =>
+    primaryArguments.some((primary) =>
+      matchesWildcardPattern(argumentPattern, primary, overflowPolicy)
+    )
+  );
+}
+
+/** Return the normalized Bash command that matched a scoped permission rule. */
+export function matchingBashCommandText(
+  pattern: ToolPattern,
+  bashAnalysis: BashAnalysis | undefined,
+  overflowPolicy: WildcardOverflowPolicy = "match",
+): string | undefined {
+  if (!bashAnalysis || pattern.toolName !== "bash") return undefined;
+  if (bashAnalysis.errors.length > 0) return undefined;
+  if (!pattern.argumentPattern) return undefined;
+  const argumentPattern = normalizedBashArgumentPattern(pattern);
+  const command = bashAnalysis.commands.find((candidate) =>
+    matchesBashArgumentPattern(argumentPattern, candidate.text, overflowPolicy)
+  );
+  if (command) return command.text;
+  return matchesBashArgumentPattern(argumentPattern, bashAnalysis.source, overflowPolicy)
+    ? bashAnalysis.source
+    : undefined;
+}
+
+function redirectListsMatch(
+  patternRedirects: BashRedirectAnalysis[],
+  inputRedirects: BashRedirectAnalysis[],
+): boolean {
+  if (patternRedirects.length !== inputRedirects.length) return false;
+  return patternRedirects.every((pattern, index) => {
+    const input = inputRedirects[index];
+    if (!input || pattern.heredoc || input.heredoc || input.targetDynamic) {
+      return false;
+    }
+    if (
+      pattern.operator !== input.operator ||
+      pattern.fileDescriptor !== input.fileDescriptor ||
+      pattern.variableName !== input.variableName
+    ) {
+      return false;
+    }
+    if (pattern.target === undefined) return input.target === undefined;
+    if (input.target === undefined) return false;
+    return matchesWildcardPattern(pattern.target, input.target, "no-match");
+  });
+}
+
+function commandMatchesAllowPattern(
+  patternCommand: BashCommandAnalysis,
+  inputCommand: BashCommandAnalysis,
+): boolean {
+  return matchesWildcardPattern(
+    patternCommand.text,
+    inputCommand.text,
+    "no-match",
+  ) && redirectListsMatch(patternCommand.redirects, inputCommand.redirects);
+}
+
+function structuresMatch(pattern: BashAnalysis, input: BashAnalysis): boolean {
+  return pattern.structure.length === input.structure.length &&
+    pattern.structure.every((token, index) => token === input.structure[index]);
+}
+
+function allRedirectsAreCommandRedirects(analysis: BashAnalysis): boolean {
+  return analysis.redirects.length === analysis.commands.reduce(
+    (count, command) => count + command.redirects.length,
+    0,
+  );
+}
+
+function isStructurallyPlainSingleCommand(analysis: BashAnalysis): boolean {
+  if (analysis.commands.length !== 1) return false;
+  if (analysis.structure.length !== 3 + analysis.redirects.length) return false;
+  if (analysis.structure[0] !== "script:1") return false;
+  if (analysis.structure[1] !== "node:Statement:foreground:0") return false;
+  if (!/^node:Command:\d+:\d+$/.test(analysis.structure[2] ?? "")) {
+    return false;
+  }
+  return analysis.structure.slice(3).every((token) =>
+    token.startsWith("redirect:")
+  );
+}
+
+function supportsPerCommandAllowPatterns(analysis: BashAnalysis): boolean {
+  return analysis.structure.every((token) =>
+    token.startsWith("script:") ||
+    token.startsWith("node:Statement:foreground:") ||
+    token.startsWith("node:Command:") ||
+    token.startsWith("node:AndOr:") ||
+    token.startsWith("node:Pipeline:plain:plain:") ||
+    token.startsWith("redirect:")
+  );
+}
+
+/** Whether permission allow rules cover the complete tool call. */
+export function matchesAllowedToolPatterns(
+  patterns: ToolPattern[],
+  toolName: string,
+  input: Record<string, unknown>,
+  cwd: string,
+  bashAnalysis?: BashAnalysis,
+): boolean {
+  if (toolName !== "bash" || !bashAnalysis) {
+    return patterns.some((pattern) =>
+      matchesToolPattern(pattern, toolName, input, cwd, "no-match")
+    );
+  }
+  if (
+    bashAnalysis.errors.length > 0 ||
+    bashAnalysis.commands.length === 0 ||
+    !bashAnalysis.allowStructureSafe
+  ) {
+    return false;
+  }
+  if (
+    bashAnalysis.commands.some((command) =>
+      command.dynamicName || command.dynamicShellScript
+    )
+  ) {
+    return false;
+  }
+
+  for (const pattern of patterns) {
+    if (pattern.toolName !== "bash") continue;
+    const patternAnalysis = bashPatternAnalyses.get(pattern);
+    if (
+      !patternAnalysis ||
+      patternAnalysis.errors.length > 0 ||
+      !patternAnalysis.allowStructureSafe ||
+      isStructurallyPlainSingleCommand(patternAnalysis) ||
+      patternAnalysis.commands.length !== bashAnalysis.commands.length ||
+      !structuresMatch(patternAnalysis, bashAnalysis) ||
+      !redirectListsMatch(patternAnalysis.redirects, bashAnalysis.redirects)
+    ) {
+      continue;
+    }
+    if (
+      patternAnalysis.commands.every((patternCommand, index) => {
+        const inputCommand = bashAnalysis.commands[index];
+        return !!inputCommand &&
+          commandMatchesAllowPattern(patternCommand, inputCommand);
+      })
+    ) {
+      return true;
+    }
+  }
+
+  const hasBareBashPattern = patterns.some((pattern) =>
+    pattern.toolName === "bash" && pattern.argumentPattern === undefined
+  );
+  if (
+    !hasBareBashPattern &&
+    !supportsPerCommandAllowPatterns(bashAnalysis)
+  ) {
+    return false;
+  }
+  if (!allRedirectsAreCommandRedirects(bashAnalysis)) return false;
+  return bashAnalysis.commands.every((command) =>
+    patterns.some((pattern) => {
+      if (pattern.toolName !== "bash") return false;
+      if (pattern.argumentPattern === undefined) {
+        return command.redirects.length === 0;
+      }
+      const patternAnalysis = bashPatternAnalyses.get(pattern);
+      if (
+        !patternAnalysis ||
+        patternAnalysis.errors.length > 0 ||
+        !isStructurallyPlainSingleCommand(patternAnalysis)
+      ) {
+        return false;
+      }
+      const patternCommand = patternAnalysis.commands[0];
+      return !!patternCommand &&
+        commandMatchesAllowPattern(patternCommand, command);
+    })
+  );
 }

package/node_modules/@czottmann/pi-automode/extensions/auto-mode.ts

@@ -7,6 +7,7 @@
  */
 
 export * from "./auto-mode/classifier.ts";
+export * from "./auto-mode/bash.ts";
 export * from "./auto-mode/config.ts";
 export * from "./auto-mode/constants.ts";
 export * from "./auto-mode/extension.ts";

package/node_modules/@czottmann/pi-automode/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@czottmann/pi-automode",
-  "version": "1.12.0",
+  "version": "1.13.0",
   "description": "Claude Code-style auto mode guardrail for pi.",
   "repository": {
     "url": "https://github.com/czottmann/pi-automode"
@@ -54,5 +54,8 @@
     "tsx": "^4.22.4",
     "typebox": "^1.3.10",
     "typescript": "^5.8.0"
+  },
+  "dependencies": {
+    "unbash": "4.0.10"
   }
 }

package/node_modules/@herbertgao/pi-cc-extensions/README.en.md

@@ -61,6 +61,7 @@ Run `/reload` after installation.
   "useSummaryTitlesAsThinkingTitle": true, // use the latest provider summary as the active thinking title
   "previewLines": 3,                       // thinking preview lines; 0 hides the preview body
   "animationIntervalMs": 90,               // thinking title animation interval in ms
+  "dimThinkingText": false,                // dim thinking body text
   "showStartupHeader": true,               // custom startup header (logo + tips) toggle
   "scrollStepLines": 3,                    // fullscreen mouse wheel scroll lines
   "enableSessionReference": true,          // @ session references
@@ -101,5 +102,5 @@ bun run typecheck
 
 ## Credits
 
-- Derived from [`minuque/pi-cc-extensions` v0.8.66](https://github.com/minuque/pi-cc-extensions/releases/tag/v0.8.66) (`e971a39`) under the MIT license.
+- Derived from [`minuque/pi-cc-extensions` v0.8.67](https://github.com/minuque/pi-cc-extensions/releases/tag/v0.8.67) (`bc58504`) under the MIT license.
 - Rich diffs are adapted from [`MasuRii/pi-tool-display`](https://github.com/MasuRii/pi-tool-display) (MIT). See [`extensions/renderer/tool/diff/ATTRIBUTION.md`](./extensions/renderer/tool/diff/ATTRIBUTION.md).

package/node_modules/@herbertgao/pi-cc-extensions/README.md

@@ -61,6 +61,7 @@ pi install npm:@herbertgao/pi-cc-extensions
   "useSummaryTitlesAsThinkingTitle": true, // 用最新 provider 摘要作为思考标题
   "previewLines": 3,                       // thinking 预览行数，0 隐藏预览正文
   "animationIntervalMs": 90,               // thinking 标题动画间隔（毫秒）
+  "dimThinkingText": false,                // thinking 正文使用 dim 色
   "showStartupHeader": true,               // 自定义启动头（logo + tips）开关
   "scrollStepLines": 3,                    // fullscreen 滚轮滚动步进行数
   "enableSessionReference": true,          // @ session 引用
@@ -101,5 +102,5 @@ bun run typecheck
 
 ## 致谢
 
-- 基于 MIT 许可的 [`minuque/pi-cc-extensions` v0.8.66](https://github.com/minuque/pi-cc-extensions/releases/tag/v0.8.66)（`e971a39`）衍生维护。
+- 基于 MIT 许可的 [`minuque/pi-cc-extensions` v0.8.67](https://github.com/minuque/pi-cc-extensions/releases/tag/v0.8.67)（`bc58504`）衍生维护。
 - Rich diff 改编自 [`MasuRii/pi-tool-display`](https://github.com/MasuRii/pi-tool-display)（MIT）；详见 [`extensions/renderer/tool/diff/ATTRIBUTION.md`](./extensions/renderer/tool/diff/ATTRIBUTION.md)。

package/node_modules/@herbertgao/pi-cc-extensions/extensions/config/config.ts

@@ -24,6 +24,7 @@ export type Config = {
 	useSummaryTitlesAsThinkingTitle: boolean;
 	previewLines: number;
 	animationIntervalMs: number;
+	dimThinkingText: boolean;
 	showStartupHeader: boolean;
 	scrollStepLines: number;
 	enableSessionReference: boolean;
@@ -75,6 +76,7 @@ export const DEFAULT_CONFIG: Config = {
 	useSummaryTitlesAsThinkingTitle: true,
 	previewLines: 3,
 	animationIntervalMs: 90,
+	dimThinkingText: false,
 	showStartupHeader: true,
 	scrollStepLines: 3,
 	enableSessionReference: true,
@@ -168,6 +170,7 @@ export function normalizeConfig(input: unknown): Config {
 			source.animationIntervalMs,
 			DEFAULT_CONFIG.animationIntervalMs,
 		),
+		dimThinkingText: source.dimThinkingText === true,
 		showStartupHeader: source.showStartupHeader !== false,
 		scrollStepLines: pickPositiveInt(source.scrollStepLines, DEFAULT_CONFIG.scrollStepLines, 1, 50),
 		enableSessionReference: source.enableSessionReference !== false,
@@ -217,6 +220,7 @@ export function formatConfigStatus(source: Config = config): string {
 		`thinkingTitle=${source.useSummaryTitlesAsThinkingTitle ? "summary" : "default"}`,
 		`thinkingPreview=${source.previewLines}`,
 		`thinkingAnimation=${source.animationIntervalMs}ms`,
+		`thinkingDim=${source.dimThinkingText ? "on" : "off"}`,
 		`startupHeader=${source.showStartupHeader ? "on" : "off"}`,
 		`scrollStep=${source.scrollStepLines}`,
 		`sessionRef=${source.enableSessionReference ? "on" : "off"}`,

package/node_modules/@herbertgao/pi-cc-extensions/extensions/config/panel.ts

@@ -349,6 +349,15 @@ export async function showCcstylePanel(
 			submenu: (_current: string, closeSubmenu: (selected?: string) => void) =>
 				buildNumberInputSubmenu(theme, thinkingAnimationSetting, closeSubmenu),
 		};
+		const thinkingDimSetting = {
+			id: "dimThinkingText",
+			label: "Dim thinking text",
+			description: config.dimThinkingText
+				? "Thinking text uses the theme's dim color."
+				: "Keep the default thinking text color.",
+			currentValue: config.dimThinkingText ? "on" : "off",
+			values: ["on", "off"],
+		};
 		const startupHeaderSetting = {
 			id: "showStartupHeader",
 			label: "Startup header",
@@ -505,6 +514,12 @@ export async function showCcstylePanel(
 					);
 					thinkingAnimationSetting.currentValue = String(config.animationIntervalMs);
 					break;
+				case "dimThinkingText":
+					config.dimThinkingText = value === "on";
+					thinkingDimSetting.description = config.dimThinkingText
+						? "Thinking text uses the theme's dim color."
+						: "Keep the default thinking text color.";
+					break;
 				case "showStartupHeader":
 					config.showStartupHeader = value === "on";
 					startupHeaderSetting.description = config.showStartupHeader
@@ -548,7 +563,12 @@ export async function showCcstylePanel(
 			{
 				id: "thinking",
 				label: "Thinking",
-				items: [thinkingTitleSetting, thinkingPreviewSetting, thinkingAnimationSetting],
+				items: [
+					thinkingTitleSetting,
+					thinkingPreviewSetting,
+					thinkingAnimationSetting,
+					thinkingDimSetting,
+				],
 			},
 			{
 				id: "ui",

package/node_modules/@herbertgao/pi-cc-extensions/extensions/feature/agent-summary/core.ts

@@ -26,7 +26,7 @@ export type AgentSummaryData = {
 
 export function classifyTool(toolName: string): AgentToolCategory {
 	const base = toolName.split(".").pop() ?? toolName;
-	if (base === "bash") return "bash";
+	if (base === "bash" || base === "powershell") return "bash";
 	if (base === "read") return "read";
 	if (base === "edit") return "edit";
 	if (base === "write") return "write";

package/node_modules/@herbertgao/pi-cc-extensions/extensions/feature/context.ts

@@ -1,7 +1,9 @@
 import {
 	type ExtensionAPI,
 	type ExtensionCommandContext,
+	type Skill,
 	estimateTokens,
+	formatSkillsForPrompt,
 	getMarkdownTheme,
 } from "@earendil-works/pi-coding-agent";
 import { Key, Markdown, matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
@@ -287,6 +289,11 @@ const tokenEstimate = (value: unknown): number => {
 	return Math.max(0, Math.ceil(text.length / 4));
 };
 
+function embeddedTokens(prompt: string, chunk: string): number {
+	if (!chunk || !prompt.includes(chunk)) return 0;
+	return tokenEstimate(chunk);
+}
+
 type ToolPreviewInfo = {
 	name: string;
 	description?: string;
@@ -359,12 +366,7 @@ export function formatTokens(tokens: number): string {
 
 type SystemPromptOptions = {
 	contextFiles?: Array<{ path: string; content: string }>;
-	skills?: Array<{
-		name: string;
-		description?: string;
-		filePath?: string;
-		disableModelInvocation?: boolean;
-	}>;
+	skills?: Skill[];
 	selectedTools?: string[];
 	toolSnippets?: Record<string, string>;
 	promptGuidelines?: string[];
@@ -386,19 +388,11 @@ export function collectContextBreakdown(ctx: ExtensionCommandContext): ContextBr
 	const systemPrompt = typeof ctx.getSystemPrompt === "function" ? ctx.getSystemPrompt() : "";
 
 	const contextFileTokens = (options.contextFiles ?? []).reduce(
-		(sum, file) => sum + tokenEstimate(file.content),
+		(sum, file) => sum + embeddedTokens(systemPrompt, file.content),
 		0,
 	);
-	// Prefer field-level estimates over JSON.stringify(whole skill).
-	const skillTokens = (options.skills ?? []).reduce((sum, skill) => {
-		if (!skill || typeof skill !== "object") return sum + tokenEstimate(skill);
-		return (
-			sum +
-			tokenEstimate(skill.name) +
-			tokenEstimate(skill.description) +
-			tokenEstimate(skill.filePath)
-		);
-	}, 0);
+	const skillsText = formatSkillsForPrompt(options.skills ?? []).trim();
+	const skillTokens = embeddedTokens(systemPrompt, skillsText);
 	const tools = options.selectedTools ?? [];
 	const snippets = options.toolSnippets;
 	let toolTokens = tokenEstimate(options.promptGuidelines);
@@ -455,11 +449,17 @@ export default function contextUsageExtension(pi: ExtensionAPI) {
 			const estimated = breakdown.parts.reduce((sum, part) => sum + part.tokens, 0);
 			const fixedParts = breakdown.parts.filter(
 				(part) =>
-					part.label === "System prompt" || part.label === "Memory" || part.label === "Tools",
+					part.label === "System prompt" ||
+					part.label === "Memory" ||
+					part.label === "Skills" ||
+					part.label === "Tools",
 			);
 			const variableParts = breakdown.parts.filter(
 				(part) =>
-					part.label !== "System prompt" && part.label !== "Memory" && part.label !== "Tools",
+					part.label !== "System prompt" &&
+					part.label !== "Memory" &&
+					part.label !== "Skills" &&
+					part.label !== "Tools",
 			);
 			const orderedParts = [...fixedParts, ...variableParts];
 			const fixedTokens = fixedParts.reduce((sum, part) => sum + part.tokens, 0);

package/node_modules/@herbertgao/pi-cc-extensions/extensions/renderer/compact-mode.ts

@@ -71,7 +71,8 @@ export function styleCompactThinkingText(
 	bold = false,
 ): string {
 	if (!theme) return text;
-	const colored = typeof theme.fg === "function" ? theme.fg("thinkingText", text) : text;
+	const color = config.dimThinkingText ? "dim" : "thinkingText";
+	const colored = typeof theme.fg === "function" ? theme.fg(color, text) : text;
 	const weighted = bold && typeof theme.bold === "function" ? theme.bold(colored) : colored;
 	return typeof theme.italic === "function" ? theme.italic(weighted) : weighted;
 }
@@ -1119,7 +1120,8 @@ export function installCompactMode(deps: CompactModeInstallDeps): CompactModeHoo
 		}
 		const name = String(this.toolName ?? "");
 		if (EDIT_WRITE_TOOLS.has(name)) {
-			if (!this.result || this.isPartial === true) scheduleAnimation(this);
+			if (this.executionStarted && (!this.result || this.isPartial === true))
+				scheduleAnimation(this);
 			const lines = compactEditWriteLine(this, width, deps.writeMetadata);
 			if (this.expanded !== true) return lines;
 			return compactEditWriteExpandedLines(this, width, deps.writeMetadata);

package/node_modules/@herbertgao/pi-cc-extensions/extensions/renderer/default-mode.ts

@@ -318,7 +318,7 @@ function createCcstyleTool(
 			const isPending =
 				visualState === "pending" ||
 				(!visualState && (context?.isPartial || context?.executionStarted));
-			if (isPending) scheduleAnimation(context);
+			if (isPending && context?.executionStarted) scheduleAnimation(context);
 			const rawIcon = isPending ? pendingIcon(toolName) : settledIcon(toolName, visualState);
 			const icon =
 				visualState === "success"
@@ -678,6 +678,7 @@ export function installToolExpandedBackground(): () => void {
 	const host = globalThis as any;
 	const previous = host[TOOL_EXPANDED_BACKGROUND_PATCH] as ToolExpandedBackgroundPatch | undefined;
 	if (previous) previous.dispose();
+	// SAFETY: Pi's runtime ToolExecutionComponent prototype owns updateDisplay; its public type omits it.
 	const prototype = ToolExecutionComponent.prototype as unknown as { updateDisplay: () => void };
 	const original = prototype.updateDisplay;
 	const patch: ToolExpandedBackgroundPatch = {