pi-cc-extensions 0.1.5 → 0.3.0

package/README.md

@@ -4,7 +4,7 @@
 
 <p align="center">
   <a href="#安装"><img alt="Pi package" src="https://img.shields.io/badge/Pi-package-58B7FF?style=flat-square"></a>
-  <a href="./package.json"><img alt="Version 0.1.3" src="https://img.shields.io/badge/version-0.1.3-66E3C4?style=flat-square"></a>
+  <a href="./package.json"><img alt="Version 0.2.0" src="https://img.shields.io/badge/version-0.2.0-66E3C4?style=flat-square"></a>
   <a href="#兼容性"><img alt="Node.js 22.19 or newer" src="https://img.shields.io/badge/Node.js-%E2%89%A522.19-66E3C4?style=flat-square"></a>
   <a href="./extensions"><img alt="TypeScript extensions" src="https://img.shields.io/badge/TypeScript-extensions-3178C6?style=flat-square"></a>
 </p>

package/extensions/ccstyle-powerline/fixed-editor/terminal-split.ts

@@ -388,6 +388,8 @@ export class TerminalSplitCompositor {
   private maxScrollOffset = 0;
   private lastRootLineCount = 0;
   private rootLines: string[] = [];
+  private rootWindowWidth = 0;
+  private rootWindowRawRows = 0;
   private suppressRootGrowthAdjustment = false;
   private readonly toolExpansionStarts = new Map<string, number>();
   private visibleRootStart = 0;
@@ -399,6 +401,8 @@ export class TerminalSplitCompositor {
   private selectionAnchor: SelectionPoint | null = null;
   private selectionFocus: SelectionPoint | null = null;
   private selectionDragging = false;
+  private batchingMouseInput = false;
+  private selectionRepaintPending = false;
   private preserveSelectionFocusOnRelease = false;
   private lastLeftPress: { area: SelectionArea; line: number; at: number } | null = null;
   private consumedClusterClick = false;
@@ -554,6 +558,8 @@ export class TerminalSplitCompositor {
     this.lastLeftPress = null;
     this.hoveredRootLine = null;
     this.rootLines = [];
+    this.rootWindowWidth = 0;
+    this.rootWindowRawRows = 0;
     this.visibleRootLines = [];
     this.visibleRootStart = 0;
     this.lastRootLineCount = 0;
@@ -597,6 +603,17 @@ export class TerminalSplitCompositor {
     const rawRows = this.getRawRows();
     const width = Math.max(1, this.terminal.columns || 80);
     const cluster = this.getCluster(width, rawRows);
+    const scrollableRows = Math.max(1, rawRows - cluster.lines.length);
+    // A cluster-only paint cannot change the split point safely. Fall back to
+    // the normal frame when width, terminal height, or cluster height changed.
+    if (
+      this.rootWindowWidth !== width
+      || this.rootWindowRawRows !== rawRows
+      || (this.visibleScrollableRows > 0 && this.visibleScrollableRows !== scrollableRows)
+    ) {
+      this.requestRender();
+      return;
+    }
     if (cluster.lines.length === 0) return;
 
     this.originalWrite(
@@ -694,6 +711,8 @@ export class TerminalSplitCompositor {
 
     const rawRows = this.getRawRows();
     const renderWidth = Math.max(1, width);
+    this.rootWindowWidth = renderWidth;
+    this.rootWindowRawRows = rawRows;
     const cluster = this.getCluster(renderWidth, rawRows);
     const scrollableRows = Math.max(1, rawRows - cluster.lines.length);
     const renderedLines = this.originalRender(renderWidth);
@@ -717,6 +736,28 @@ export class TerminalSplitCompositor {
     return this.updateVisibleRootWindow(scrollableRows);
   }
 
+  private ensureRootWindow(width: number): void {
+    if (!this.originalRender) return;
+
+    const renderWidth = Math.max(1, width);
+    const rawRows = this.getRawRows();
+    const cluster = this.getCluster(renderWidth, rawRows);
+    const scrollableRows = Math.max(1, rawRows - cluster.lines.length);
+    const sameRootDimensions = this.rootWindowWidth === renderWidth && this.rootWindowRawRows === rawRows;
+
+    if (sameRootDimensions && this.visibleScrollableRows > 0) {
+      if (this.visibleScrollableRows !== scrollableRows) {
+        this.maxScrollOffset = Math.max(0, this.rootLines.length - scrollableRows);
+        this.scrollOffset = Math.max(0, Math.min(this.scrollOffset, this.maxScrollOffset));
+        this.pendingImageCleanup = true;
+        this.updateVisibleRootWindow(scrollableRows);
+      }
+      return;
+    }
+
+    this.refreshRootWindow(renderWidth);
+  }
+
   private handleInput(data: string): { consume?: boolean; data?: string } | undefined {
     if (this.disposed || this.hasVisibleOverlay()) return undefined;
 
@@ -735,8 +776,17 @@ export class TerminalSplitCompositor {
 
     const mousePackets = this.mouseScroll ? parseSgrMousePackets(data) : null;
     if (mousePackets) {
-      for (const packet of mousePackets) {
-        this.handleMousePacket(packet);
+      this.batchingMouseInput = true;
+      try {
+        for (const packet of mousePackets) {
+          this.handleMousePacket(packet);
+        }
+      } finally {
+        this.batchingMouseInput = false;
+      }
+      if (this.selectionRepaintPending) {
+        this.selectionRepaintPending = false;
+        this.repaintSelection(Math.max(1, this.terminal.columns || 80));
       }
       return { consume: true };
     }
@@ -777,7 +827,11 @@ export class TerminalSplitCompositor {
       return;
     }
 
-    this.refreshRootWindow(Math.max(1, this.terminal.columns || 80));
+    const width = Math.max(1, this.terminal.columns || 80);
+    // Mouse selection and clicks operate on the last painted root window. Avoid
+    // re-rendering the complete transcript for every mouse packet; refresh only
+    // on the first packet or after a terminal resize.
+    this.ensureRootWindow(width);
     const location = this.selectionLocationForPacket(packet);
 
     if (isRightPress(packet)) {
@@ -845,6 +899,10 @@ export class TerminalSplitCompositor {
           this.clearSelection();
           this.lastLeftPress = null;
           this.consumedClusterClick = true;
+          // refreshRootWindow() updated the logical lines above, but the TUI
+          // render is scheduled asynchronously. Paint the collapsed/expanded
+          // viewport immediately so stale rows cannot remain until the next drag.
+          this.repaintScrollableViewport(Math.max(1, this.terminal.columns || 80));
           this.requestRender();
           return;
         }
@@ -869,7 +927,7 @@ export class TerminalSplitCompositor {
       this.lastLeftPress = null;
       this.preserveSelectionFocusOnRelease = false;
       this.selectionFocus = location.point;
-      this.requestRender();
+      this.repaintSelection(width);
       return;
     }
   }
@@ -904,7 +962,7 @@ export class TerminalSplitCompositor {
     } else {
       this.clearSelection();
     }
-    this.requestRender();
+    this.repaintSelection(Math.max(1, this.terminal.columns || 80));
   }
 
   private startSelection(location: SelectionLocation): void {
@@ -922,7 +980,7 @@ export class TerminalSplitCompositor {
       this.selectionDragging = true;
       this.preserveSelectionFocusOnRelease = true;
       this.lastLeftPress = null;
-      this.requestRender();
+      this.repaintSelection(Math.max(1, this.terminal.columns || 80));
       return;
     }
 
@@ -932,7 +990,7 @@ export class TerminalSplitCompositor {
     this.selectionDragging = true;
     this.preserveSelectionFocusOnRelease = false;
     this.lastLeftPress = { area: location.area, line, at: now };
-    this.requestRender();
+    this.repaintSelection(Math.max(1, this.terminal.columns || 80));
   }
 
   private selectionLocationForPacket(packet: SgrMousePacket): SelectionLocation | null {
@@ -974,7 +1032,7 @@ export class TerminalSplitCompositor {
       line: edgeLine,
       col: Math.max(0, packet.col - 1),
     };
-    this.requestRender();
+    this.repaintSelection(Math.max(1, this.terminal.columns || 80));
     return true;
   }
 
@@ -1065,7 +1123,7 @@ export class TerminalSplitCompositor {
 
   private scrollBy(delta: number): void {
     const width = Math.max(1, this.terminal.columns || 80);
-    this.refreshRootWindow(width);
+    this.ensureRootWindow(width);
 
     const wasScrolled = this.scrollOffset > 0;
     const nextOffset = Math.max(0, Math.min(this.scrollOffset + delta, this.maxScrollOffset));
@@ -1088,12 +1146,24 @@ export class TerminalSplitCompositor {
     }
   }
 
-  private repaintScrollableViewport(width: number): void {
-    if (this.disposed || this.writing || this.hasVisibleOverlay()) return;
+  private repaintSelection(width: number): void {
+    if (this.batchingMouseInput) {
+      this.selectionRepaintPending = true;
+      return;
+    }
+    if (!this.repaintScrollableViewport(width)) {
+      this.requestRender();
+    }
+  }
+
+  private repaintScrollableViewport(width: number): boolean {
+    if (this.disposed || this.writing || this.hasVisibleOverlay()) return false;
 
     const rawRows = this.getRawRows();
     const cluster = this.getCluster(width, rawRows);
     const scrollableRows = Math.max(1, rawRows - cluster.lines.length);
+    this.maxScrollOffset = Math.max(0, this.rootLines.length - scrollableRows);
+    this.scrollOffset = Math.max(0, Math.min(this.scrollOffset, this.maxScrollOffset));
     const start = this.updateVisibleRootWindow(scrollableRows);
     let buffer = beginSynchronizedOutput()
       + this.consumePendingImageCleanup()
@@ -1113,6 +1183,7 @@ export class TerminalSplitCompositor {
     buffer += this.mouseReportingStateGuard();
     buffer += endSynchronizedOutput();
     this.originalWrite(buffer);
+    return true;
   }
 
   private pauseMouseReportingForContextMenu(textToRestoreToClipboard: string | null = null): void {

package/extensions/ccstyle-powerline/powerline.ts

@@ -984,6 +984,7 @@ export default function powerlineFooter(pi: ExtensionAPI): PowerlineController {
   let fixedEditorContainer: any = null;
   let fixedWidgetContainerAbove: any = null;
   let fixedWidgetContainerBelow: any = null;
+  let statusRenderNeedsFullRender = false;
   let stashShortcutInputUnsubscribe: (() => void) | null = null;
   let dismissWelcomeOverlay: (() => void) | null = null;
   let welcomeHeaderActive = false;
@@ -1024,7 +1025,12 @@ export default function powerlineFooter(pi: ExtensionAPI): PowerlineController {
       return;
     }
 
-    tuiRef?.requestRender();
+    if (fixedEditorCompositor && !statusRenderNeedsFullRender) {
+      fixedEditorCompositor.requestRepaint();
+    } else {
+      tuiRef?.requestRender();
+    }
+    statusRenderNeedsFullRender = false;
   }, STATUS_RENDER_DEBOUNCE_MS);
 
   const resetLayoutCache = () => {
@@ -1039,6 +1045,7 @@ export default function powerlineFooter(pi: ExtensionAPI): PowerlineController {
 
   const requestImmediateStatusRender = (options: { deferDuringTyping?: boolean } = {}) => {
     layoutDirty = true;
+    statusRenderNeedsFullRender = true;
     if (options.deferDuringTyping !== false && Date.now() - lastEditorInputAt < EDITOR_STATUS_DEFER_MS) {
       statusRenderScheduler.schedule();
       return;
@@ -1244,6 +1251,7 @@ export default function powerlineFooter(pi: ExtensionAPI): PowerlineController {
     // Read from the extension runtime rather than retaining a session context
     // method across /reload. The runtime already restored the effective level.
     currentThinkingLevel = pi.getThinkingLevel();
+    recalculateUsageFromEvents(ctx);
 
     if (ctx.hasUI) {
       ctx.ui.setStatus("stash", undefined);
@@ -1295,6 +1303,7 @@ export default function powerlineFooter(pi: ExtensionAPI): PowerlineController {
     welcomeOverlayShouldDismiss = false;
     welcomeDismissScheduler.cancel();
     statusRenderScheduler.cancel();
+    statusRenderNeedsFullRender = false;
     restoreFooterStatusRepaintHook?.();
     restoreFooterStatusRepaintHook = null;
     teardownFixedEditorCompositor(isTerminalExit ? { resetExtendedKeyboardModes: true } : undefined);
@@ -1379,6 +1388,7 @@ export default function powerlineFooter(pi: ExtensionAPI): PowerlineController {
     currentCtx = ctx;
     currentThinkingLevel = pi.getThinkingLevel();
     liveAssistantUsage = null;
+    recalculateUsageFromEvents(ctx);
     requestImmediateStatusRender({ deferDuringTyping: false });
   });
 
@@ -1388,6 +1398,8 @@ export default function powerlineFooter(pi: ExtensionAPI): PowerlineController {
     // intentionally unknown until the next model response, so the segment will
     // display "?" rather than a stale percentage.
     liveAssistantUsage = null;
+    // Recalculate usage after compaction (old events removed, summary added).
+    recalculateUsageFromEvents(ctx);
     fixedEditorCompositor?.resetTranscriptLayout();
     resetLayoutCache();
     requestImmediateStatusRender({ deferDuringTyping: false });
@@ -1455,6 +1467,13 @@ export default function powerlineFooter(pi: ExtensionAPI): PowerlineController {
         liveAssistantUsage = null;
       } else if (getUsageTokenTotal(event.message.usage) > 0) {
         liveAssistantUsage = event.message.usage;
+        // Incrementally update cached usage (O(1) instead of rescanning all events).
+        cachedUsage.input += event.message.usage.input;
+        cachedUsage.output += event.message.usage.output;
+        cachedUsage.cacheRead += event.message.usage.cacheRead;
+        cachedUsage.cacheWrite += event.message.usage.cacheWrite;
+        cachedUsage.cost += event.message.usage.cost.total;
+        cachedLastAssistantUsage = event.message.usage;
       }
     }
     requestImmediateStatusRender({ deferDuringTyping: false });
@@ -1841,6 +1860,7 @@ export default function powerlineFooter(pi: ExtensionAPI): PowerlineController {
           tuiRef = null;
           currentEditor = null;
           statusRenderScheduler.cancel();
+          statusRenderNeedsFullRender = false;
           resetLayoutCache();
           ctx.ui.notify("Powerline disabled", "info");
         }
@@ -2130,46 +2150,47 @@ export default function powerlineFooter(pi: ExtensionAPI): PowerlineController {
     },
   });
 
-  function buildSegmentContext(ctx: any, theme: Theme): SegmentContext {
-    const presetDef = getPreset(config.preset);
-    const colors: ColorScheme = presetDef.colors ?? getDefaultColors();
-
-    // Build usage stats and get thinking level from session
-    let input = 0, output = 0, cacheRead = 0, cacheWrite = 0, cost = 0;
-    let lastAssistant: AssistantMessage | undefined;
-    let thinkingLevelFromSession: string | null = null;
-    
-    const sessionEvents = ctx.sessionManager?.getBranch?.() ?? [];
-    for (const e of sessionEvents) {
-      if (!isRecord(e)) {
-        continue;
-      }
-
-      // Check for thinking level change entries
+  // ═══ Incremental usage stats cache ═══
+  // Avoids scanning all session events on every render (was O(n) per frame).
+  // Updated incrementally on message_end / session_start / session_compact.
+  let cachedUsage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
+  let cachedLastAssistantUsage: SessionAssistantUsage | null = null;
+  let cachedThinkingLevel: string | null = null;
+
+  function recalculateUsageFromEvents(ctx: any): void {
+    cachedUsage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
+    cachedLastAssistantUsage = null;
+    cachedThinkingLevel = null;
+    const events = ctx?.sessionManager?.getBranch?.() ?? [];
+    for (const e of events) {
+      if (!isRecord(e)) continue;
       if (e.type === "thinking_level_change" && typeof e.thinkingLevel === "string") {
-        thinkingLevelFromSession = e.thinkingLevel;
-      }
-
-      if (e.type !== "message" || !isSessionAssistantMessage(e.message)) {
-        continue;
+        cachedThinkingLevel = e.thinkingLevel;
       }
-
+      if (e.type !== "message" || !isSessionAssistantMessage(e.message)) continue;
       const m = e.message;
-      if (m.stopReason === "error" || m.stopReason === "aborted") {
-        continue;
-      }
-      input += m.usage.input;
-      output += m.usage.output;
-      cacheRead += m.usage.cacheRead;
-      cacheWrite += m.usage.cacheWrite;
-      cost += m.usage.cost.total;
+      if (m.stopReason === "error" || m.stopReason === "aborted") continue;
+      cachedUsage.input += m.usage.input;
+      cachedUsage.output += m.usage.output;
+      cachedUsage.cacheRead += m.usage.cacheRead;
+      cachedUsage.cacheWrite += m.usage.cacheWrite;
+      cachedUsage.cost += m.usage.cost.total;
       if (getUsageTokenTotal(m.usage) > 0) {
-        lastAssistant = m;
+        cachedLastAssistantUsage = m.usage;
       }
     }
+  }
+
+  function buildSegmentContext(ctx: any, theme: Theme): SegmentContext {
+    const presetDef = getPreset(config.preset);
+    const colors: ColorScheme = presetDef.colors ?? getDefaultColors();
+
+    // Use cached incremental stats (O(1)) instead of scanning all events.
+    const { input, output, cacheRead, cacheWrite, cost } = cachedUsage;
+    const thinkingLevelFromSession = currentThinkingLevel ?? cachedThinkingLevel ?? "off";
 
     // Calculate context percentage.
-    const latestUsage = isStreaming ? liveAssistantUsage ?? lastAssistant?.usage : lastAssistant?.usage;
+    const latestUsage = isStreaming ? liveAssistantUsage ?? cachedLastAssistantUsage : cachedLastAssistantUsage;
     const coreContextUsage = isStreaming && liveAssistantUsage ? null : readCoreContextUsage(ctx);
     const fallbackContextTokens = latestUsage ? getUsageTokenTotal(latestUsage) : 0;
     const contextWindow = coreContextUsage?.contextWindow ?? ctx.model?.contextWindow ?? 0;
@@ -2191,7 +2212,7 @@ export default function powerlineFooter(pi: ExtensionAPI): PowerlineController {
       ? ctx.modelRegistry?.isUsingOAuth?.(ctx.model) ?? false
       : false;
 
-    const thinkingLevel = currentThinkingLevel ?? thinkingLevelFromSession ?? "off";
+    const thinkingLevel = thinkingLevelFromSession;
 
     return {
       model: ctx.model,
@@ -2511,8 +2532,9 @@ export default function powerlineFooter(pi: ExtensionAPI): PowerlineController {
         component.setExpanded(!expanded);
       } else {
         const state = (component.rendererState ??= {});
-        state.ccstyleToolExpanded = !expanded;
-        component.setExpanded?.(Boolean(component.expanded));
+        const nextExpanded = !expanded;
+        state.ccstyleToolExpanded = nextExpanded;
+        component.setExpanded?.(nextExpanded);
         component.invalidate?.();
       }
       // The compositor refreshes and renders once after applying its viewport
@@ -2523,8 +2545,13 @@ export default function powerlineFooter(pi: ExtensionAPI): PowerlineController {
         key: expandableRootComponentKey(component),
       };
     };
-    const isExpandableRootLine = (line: number, _col: number, text: string): boolean =>
-      Boolean(findExpandableRootComponentAtText(line, text));
+    const isExpandableRootLine = (_line: number, _col: number, text: string): boolean => {
+      // O(1) regex check instead of full tree traversal + component.render().
+      // Click handler (onRootClick) still uses findExpandableRootComponentAtText for accurate matching.
+      if (!text) return false;
+      const stripped = stripAnsiForToolClick(text);
+      return stripped ? /(?:expand|\/ click)/.test(stripped) : false;
+    };
     const readRenderTheme = (): Theme => {
       if (!currentCtx) return fallbackTheme;
       try {
@@ -2547,32 +2574,73 @@ export default function powerlineFooter(pi: ExtensionAPI): PowerlineController {
       (line.match(/\x1b\[[0-9;]*m/g) ?? []).some((sequence) =>
         sequence.slice(2, -1).split(";").includes("3"),
       );
+    // Cache expensive per-line ANSI work by rendered line content. The TUI
+    // creates a new array on every render, so caching the array reference does
+    // not help once the transcript grows.
+    const MAX_DECORATION_CACHE_ENTRIES = 4096;
+    let decorationTheme: Theme | null = null;
+    let thinkingColor = "";
+    const thinkingLineCache = new Map<string, boolean>();
+    const nonEmptyLineCache = new Map<string, boolean>();
+    const unboldLineCache = new Map<string, string>();
+
+    const trimDecorationCache = <T>(cache: Map<string, T>): void => {
+      if (cache.size > MAX_DECORATION_CACHE_ENTRIES) cache.clear();
+    };
+
     const decorateThinkingLines = (lines: string[]): string[] => {
       const theme = readRenderTheme();
-      const marker = "__ccstyle_thinking__";
-      const themedMarker = theme.fg("thinkingText", marker);
-      const markerIndex = themedMarker.indexOf(marker);
-      const thinkingColor = markerIndex > 0 ? themedMarker.slice(0, markerIndex) : "";
-      const isThinking = lines.map((line) =>
-        Boolean(thinkingColor && line.includes(thinkingColor) && hasItalicStyle(line)),
-      );
+      if (theme !== decorationTheme) {
+        decorationTheme = theme;
+        const marker = "__ccstyle_thinking__";
+        const themedMarker = theme.fg("thinkingText", marker);
+        const markerIndex = themedMarker.indexOf(marker);
+        thinkingColor = markerIndex > 0 ? themedMarker.slice(0, markerIndex) : "";
+        thinkingLineCache.clear();
+      }
+
+      // Fast path: themes without a thinking color need no processing.
+      if (!thinkingColor) return lines;
+
+      const isThinking = lines.map((line) => {
+        const cached = thinkingLineCache.get(line);
+        if (cached !== undefined) return cached;
+        const value = line.includes(thinkingColor) && hasItalicStyle(line);
+        thinkingLineCache.set(line, value);
+        trimDecorationCache(thinkingLineCache);
+        return value;
+      });
       const decorated = [...isThinking];
+      const hasText = (line: string): boolean => {
+        const cached = nonEmptyLineCache.get(line);
+        if (cached !== undefined) return cached;
+        const value = Boolean(stripAnsiForToolClick(line));
+        nonEmptyLineCache.set(line, value);
+        trimDecorationCache(nonEmptyLineCache);
+        return value;
+      };
 
       // Continue the guide through paragraph spacing inside one thinking block.
       for (let index = 0; index < lines.length; index++) {
-        if (stripAnsiForToolClick(lines[index] ?? "")) continue;
+        if (hasText(lines[index] ?? "")) continue;
         let before = index - 1;
-        while (before >= 0 && !stripAnsiForToolClick(lines[before] ?? "")) before--;
+        while (before >= 0 && !hasText(lines[before] ?? "")) before--;
         let after = index + 1;
-        while (after < lines.length && !stripAnsiForToolClick(lines[after] ?? "")) after++;
+        while (after < lines.length && !hasText(lines[after] ?? "")) after++;
         decorated[index] = before >= 0 && after < lines.length && isThinking[before] && isThinking[after];
       }
 
       // Keep the native thinking text styling, but do not add a guide line.
       // The guide conflicted visually with the tool status markers.
-      return lines.map((line, index) =>
-        decorated[index] ? removeThinkingBold(line) : line,
-      );
+      return lines.map((line, index) => {
+        if (!decorated[index]) return line;
+        const cached = unboldLineCache.get(line);
+        if (cached !== undefined) return cached;
+        const result = removeThinkingBold(line);
+        unboldLineCache.set(line, result);
+        trimDecorationCache(unboldLineCache);
+        return result;
+      });
     };
 
     let compositor: TerminalSplitCompositor;

package/extensions/claude-code-style.ts

@@ -178,31 +178,46 @@ function animationFrame(frames: string[], intervalMs = 120): string {
 	return frames[Math.floor(Date.now() / intervalMs) % frames.length] ?? frames[0] ?? "";
 }
 
-const activeAnimationTimers = new Set<ReturnType<typeof setTimeout>>();
+const activeAnimationContexts = new Set<any>();
+let sharedAnimationTimer: ReturnType<typeof setTimeout> | null = null;
 
 function clearAnimation(context: any) {
-	const timer = context?.state?.ccstyleAnimationTimer as ReturnType<typeof setTimeout> | undefined;
-	if (!timer) return;
-	clearTimeout(timer);
-	activeAnimationTimers.delete(timer);
-	context.state.ccstyleAnimationTimer = undefined;
+	if (!context?.state?.ccstyleAnimationScheduled) return;
+	context.state.ccstyleAnimationScheduled = false;
+	activeAnimationContexts.delete(context);
+	if (activeAnimationContexts.size === 0 && sharedAnimationTimer) {
+		clearTimeout(sharedAnimationTimer);
+		sharedAnimationTimer = null;
+	}
 }
 
 function clearAllAnimations() {
-	for (const timer of activeAnimationTimers) clearTimeout(timer);
-	activeAnimationTimers.clear();
+	for (const ctx of activeAnimationContexts) {
+		ctx.state.ccstyleAnimationScheduled = false;
+	}
+	activeAnimationContexts.clear();
+	if (sharedAnimationTimer) {
+		clearTimeout(sharedAnimationTimer);
+		sharedAnimationTimer = null;
+	}
 }
 
 function scheduleAnimation(context: any, intervalMs = 80) {
 	const state = (context.state ??= {});
-	if (state.ccstyleAnimationTimer) return;
-	const timer = setTimeout(() => {
-		activeAnimationTimers.delete(timer);
-		state.ccstyleAnimationTimer = undefined;
-		context.invalidate?.();
-	}, intervalMs);
-	state.ccstyleAnimationTimer = timer;
-	activeAnimationTimers.add(timer);
+	if (state.ccstyleAnimationScheduled) return;
+	state.ccstyleAnimationScheduled = true;
+	activeAnimationContexts.add(context);
+	if (!sharedAnimationTimer) {
+		sharedAnimationTimer = setTimeout(() => {
+			sharedAnimationTimer = null;
+			const contexts = Array.from(activeAnimationContexts);
+			activeAnimationContexts.clear();
+			for (const ctx of contexts) {
+				ctx.state.ccstyleAnimationScheduled = false;
+				ctx.invalidate?.();
+			}
+		}, intervalMs);
+	}
 }
 
 function pendingIcon(name: string): string {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-cc-extensions",
-  "version": "0.1.5",
+  "version": "0.3.0",
   "description": "Personal extensions for the Pi coding agent",
   "type": "module",
   "keywords": [
@@ -23,10 +23,11 @@
   "scripts": {
     "test": "node --test tests/**/*.test.ts",
     "typecheck": "node scripts/typecheck.mjs",
-    "postversion": "npm run typecheck && npm test && git push && git push --tags",
+    "preversion": "npm run typecheck && npm test",
     "release": "npm version patch && npm publish",
     "release:minor": "npm version minor && npm publish",
-    "release:major": "npm version major && npm publish"
+    "release:major": "npm version major && npm publish",
+    "postpublish": "git push && git push --tags"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",