pi-cc-extensions 0.8.43 → 0.8.45

package/README.en.md

@@ -42,13 +42,13 @@ Run `/reload` after installation, then try:
 ## Features
 
 
-| Feature                   | Description                                                                                      | Entry point         |
-| --------------------------- | -------------------------------------------------------------------------------------------------- | --------------------- |
-| Claude Code-style output | Tool summaries, expand/collapse, rich edit/write diffs, and `on` / `off` / `compact` modes | `/ccstyle` |
-| Fixed-editor interaction | Powered by `@tifan/pi-fixed-editor`, with runtime toggling, five-row wheel scrolling, tool clicks, and back-to-bottom control | `/ccstyle` |
-| Context inspection | Usage breakdown and previews for the system prompt, tools, skills, and messages | `/context` |
-| Session references        | Search and inject effective context from previous Sessions or existing SubAgents                 | `@session:`         |
-| Theme                     | Includes the GitHub Dark Default theme                                                           | `/theme`            |
+| Feature                  | Description                                                                                                                  | Entry point |
+| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------ | ------------- |
+| Claude Code-style output | Tool summaries, expand/collapse, rich edit/write diffs, and`on` / `off` / `compact` modes                                    | `/ccstyle`  |
+| Fixed-editor interaction | Powered by`@tifan/pi-fixed-editor`, with runtime toggling, five-row wheel scrolling, tool clicks, and back-to-bottom control | `/ccstyle`  |
+| Context inspection       | Usage breakdown and previews for the system prompt, tools, skills, and messages                                              | `/context`  |
+| Session references       | Search and inject effective context from previous Sessions or existing SubAgents                                             | `@session:` |
+| Theme                    | Bundled GitHub Dark Default and CC Dark themes                                                                               | `/theme`    |
 
 ### Output modes
 
@@ -126,12 +126,16 @@ Run `/reload` after changing extensions.
 ## Recommended companions
 
 
-| Extension                     | Purpose                                                      |
-| ------------------------------- | -------------------------------------------------------------- |
-| `npm:@tintinweb/pi-subagents` | Parallel SubAgents, background tasks, and worktree isolation |
-| `npm:pi-mcp-adapter`          | On-demand MCP tool discovery with lower context usage        |
-| `npm:pi-theme-picker`         | Theme search and live preview                                |
-| `npm:@ayulab/pi-rewind`       | Checkpoint-based code or conversation rollback               |
+| Extension                                | Purpose                                                      |
+| ------------------------------------------ | -------------------------------------------------------------- |
+| `npm:@tintinweb/pi-subagents`            | Parallel SubAgents, background tasks, and worktree isolation |
+| `npm:@tintinweb/pi-tasks`                | Claude Code-style task tracking and coordination             |
+| `npm:pi-mcp-adapter`                     | On-demand MCP tool discovery with lower context usage        |
+| `npm:@ff-labs/pi-fff`                    | FFF-powered fuzzy file and content search (fffind / ffgrep)  |
+| `npm:pi-web-access`                      | Web search, URL fetching, GitHub cloning, PDF/video parsing  |
+| `npm:pi-theme-picker`                    | Theme search and live preview                                |
+| `npm:@narumitw/pi-usage`                 | Current-account usage for Codex / Copilot / OpenRouter       |
+| `git:github.com/DietrichGebert/ponytail` | Lazy-mode coding: forces the simplest working solution       |
 
 ## Credits
 

package/README.md

@@ -10,7 +10,7 @@
 </p>
 
 <p align="center">
-  类 Claude Code 风格界面、固定编辑器、上下文检查，以及 Agent / Session 引用。
+  类 Claude Code TUI输出风格、固定编辑器、上下文检查，以及 Agent / Session 引用。
 </p>
 
 <p align="center">
@@ -38,13 +38,14 @@ pi install git:github.com/minuque/pi-cc-extensions
 
 ## 功能
 
-| 功能                 | 说明                                                                                  | 入口          |
-| -------------------- | ------------------------------------------------------------------------------------- | ------------- |
+
+| 功能                 | 说明                                                                            | 入口        |
+| ---------------------- | --------------------------------------------------------------------------------- | ------------- |
 | Claude Code 风格输出 | 工具摘要、折叠展开、rich edit/write diff，以及`on` / `off` / `compact` 三种模式 | `/ccstyle`  |
-| Fixed editor 交互    | 基于`@tifan/pi-fixed-editor`，支持动态开关、每刻度 5 行滚动、工具点击与回到底部     | `/ccstyle`  |
-| 上下文检查           | 查看上下文占用，并预览 System prompt、Tools、Skills 和消息内容                        | `/context`  |
-| Session 引用         | 搜索并注入历史 Session 或现有 SubAgent 的有效上下文                                   | `@session:` |
-| 主题                 | 随包提供内置 GitHub Dark Default 主题                                                 | `/theme`    |
+| Fixed editor 交互    | 基于`@tifan/pi-fixed-editor`，支持动态开关、每刻度 5 行滚动、工具点击与回到底部 | `/ccstyle`  |
+| 上下文检查           | 查看上下文占用，并预览 System prompt、Tools、Skills 和消息内容                  | `/context`  |
+| Session 引用         | 搜索并注入历史 Session 或现有 SubAgent 的有效上下文                             | `@session:` |
+| 主题                 | 随包提供内置 GitHub Dark Default、CC Dark 主题                                  | `/theme`    |
 
 ## 本地开发
 
@@ -73,12 +74,17 @@ pi -e .
 
 ## 推荐搭配
 
-| 扩展                            | 用途                                |
-| ------------------------------- | ----------------------------------- |
-| `npm:@tintinweb/pi-subagents` | 并行 SubAgent、后台任务与工作树隔离 |
-| `npm:pi-mcp-adapter`          | 按需发现 MCP 工具，减少上下文占用   |
-| `npm:pi-theme-picker`         | 主题搜索和实时预览                  |
-| `npm:@ayulab/pi-rewind`       | 基于 checkpoint 回退代码或对话      |
+
+| 扩展                                     | 用途                                             |
+| ------------------------------------------ | -------------------------------------------------- |
+| `npm:@tintinweb/pi-subagents`            | 并行 SubAgent、后台任务与工作树隔离              |
+| `npm:@tintinweb/pi-tasks`                | Claude Code 风格任务跟踪与协调                   |
+| `npm:pi-mcp-adapter`                     | 按需发现 MCP 工具，减少上下文占用                |
+| `npm:@ff-labs/pi-fff`                    | 模糊文件与内容检索（fffind / ffgrep）            |
+| `npm:pi-web-access`                      | 网页搜索、URL 抓取、GitHub 克隆、PDF/视频解析    |
+| `npm:pi-theme-picker`                    | 主题搜索和实时预览                               |
+| `npm:@narumitw/pi-usage`                 | 查看当前账号用量（Codex / Copilot / OpenRouter） |
+| `git:github.com/DietrichGebert/ponytail` | 极简编码：强制最懒但有效的方案                   |
 
 ## 致谢
 

package/extensions/compact-thinking.ts

@@ -1,12 +1,25 @@
-import * as piAi from "@earendil-works/pi-ai";
-import * as piCodingAgent from "@earendil-works/pi-coding-agent";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import * as piTui from "@earendil-works/pi-tui";
-import { readFileSync, rmSync } from "node:fs";
-import { createRequire } from "node:module";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { createJiti } from "jiti";
+// compact-thinking 本地内联实现。fork 自 pi-compact-thinking（MIT，
+// https://github.com/tifandotme/pi-extensions/tree/master/packages/pi-compact-thinking）。
+// 差异：
+// 1. 不再依赖上游包 —— 配置解耦，由 claude-code-style 经 installCompactThinking
+//    /updateConfig 管控（模块级 config 对象，不再读写 compact-thinking.json）。
+// 2. 合并了上游 fork patch：subagent 工具（Agent/Agents）执行期间保持思考动画，
+//    直到 tool_execution_end 或下一个 text/thinking 边界才收尾。
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+import {
+	AssistantMessageComponent,
+	type ExtensionAPI,
+	type Theme,
+} from "@earendil-works/pi-coding-agent";
+// @ts-expect-error pi-tui 类型声明的 .ts 后缀 re-export 解析失败；运行时存在
+import { getKeybindings } from "@earendil-works/pi-tui";
+import { Markdown, Spacer, Text, type Component } from "@earendil-works/pi-tui";
+
+// pi-tui 类型声明中 TUI 的 re-export 解析失败，本地用最小结构化类型（只用到 requestRender）。
+type RenderTui = { requestRender(force?: boolean): void };
+
+// pi-coding-agent 的类型声明中 AssistantMessageComponent 仅能以 value 形式使用。
+type AssistantMessageComponentLike = InstanceType<typeof AssistantMessageComponent>;
 
 export type CompactThinkingConfig = {
 	useSummaryTitlesAsThinkingTitle: boolean;
@@ -18,120 +31,639 @@ export type CompactThinkingController = {
 	updateConfig(next: CompactThinkingConfig): void;
 };
 
-type CompactThinkingOwner = {
-	owner: object;
-	stop(event?: any, ctx?: any): void;
+type DurationEntryData = {
+	messageTimestamp: number;
+	contentIndex: number;
+	durationMs: number;
 };
 
-type UpstreamHandler = (event: any, ctx: any) => void;
+type SummaryPart = {
+	title: string;
+	body: string;
+};
 
-const COMPACT_THINKING_OWNER = Symbol.for("pi.ccstyle.compact-thinking-owner");
+type ActiveThinking = {
+	messageTimestamp: number;
+	contentIndex: number;
+	startedAt: number;
+};
 
-function loadPatchedUpstream(): {
-	config: CompactThinkingConfig;
-	compactThinking: (api: ExtensionAPI) => void;
-} {
-	// Fork the upstream entry so a running subagent tool keeps the thinking
-	// loading animation until the model emits the next text/thinking boundary.
-	// Upstream finalizes on tool_execution_start / message_end, freezing the
-	// summary into a static "Thought for Xs" for the whole subagent run.
-	const upstreamRequire = createRequire(import.meta.url);
-	const upstreamIndexPath = upstreamRequire.resolve("pi-compact-thinking/index.ts");
-	const toolStartOriginal = `  pi.on("tool_execution_start", finishThinking);`;
-	const toolStartPatched = `  // Subagent tools can run for minutes: keep the thinking loading animation
-  // alive for the whole execution and only finalize once the tool ends or the
-  // model emits the next text/thinking boundary.
-  function resumeAgentThinking(message: AssistantMessage | undefined) {
-    if (activeThinking) return;
-    const content = message?.content;
-    if (!Array.isArray(content)) return;
-    const index = content.findIndex((item) => item?.type === "thinking");
-    if (index < 0) return;
-    startThinking(message, index);
-  }
-  function messageHasAgentTool(message: AssistantMessage | undefined) {
-    return (
-      Array.isArray(message?.content) &&
-      message.content.some(
-        (content) =>
-          content?.type === "toolCall" &&
-          (content.name === "Agent" ||
-            content.name === "Agents" ||
-            content.args?.subagent_type != null),
-      )
-    );
-  }
-  pi.on("tool_execution_start", (event: any) => {
-    if (event.toolName === "Agent" || event.toolName === "Agents") {
-      resumeAgentThinking(latestComponent?.lastMessage ?? undefined);
-    } else {
-      finishThinking();
-    }
-  });
-  pi.on("tool_execution_end", (event: any) => {
-    if (event.toolName === "Agent" || event.toolName === "Agents") finishThinking();
-  });`;
-	const updateBoundaryOriginal = `    } else if (
-      update.type === "text_start" ||
-      update.type === "toolcall_start" ||
-      update.type === "toolcall_delta"
-    ) {
-      finishThinking();
-    }`;
-	const updateBoundaryPatched = `    } else if (update.type === "text_start") {
-      finishThinking();
-    } else if (
-      update.type === "toolcall_start" ||
-      update.type === "toolcall_delta"
-    ) {
-      if (messageHasAgentTool(event.message)) {
-        resumeAgentThinking(event.message);
-      } else {
-        finishThinking();
-      }
-    }`;
-	const messageEndOriginal = `  pi.on("message_end", (event) => {
-    if (event.message.role === "assistant") finishThinking();
-  });`;
-	const messageEndPatched = `  pi.on("message_end", (event) => {
-    if (event.message.role !== "assistant") return;
-    // Agent tool runs after message_end; keep the ticker until tool_execution_end
-    // or the next text/thinking boundary.
-    if (messageHasAgentTool(event.message)) return;
-    finishThinking();
-  });`;
-
-	let upstreamIndexSource = readFileSync(upstreamIndexPath, "utf8");
-	if (
-		upstreamIndexSource.includes(toolStartOriginal) &&
-		upstreamIndexSource.includes(updateBoundaryOriginal) &&
-		upstreamIndexSource.includes(messageEndOriginal)
-	) {
-		upstreamIndexSource = upstreamIndexSource
-			.replace(toolStartOriginal, toolStartPatched)
-			.replace(updateBoundaryOriginal, updateBoundaryPatched)
-			.replace(messageEndOriginal, messageEndPatched);
+type AssistantInternals = {
+	contentContainer: {
+		clear(): void;
+		addChild(component: Component): void;
+	};
+	hideThinkingBlock: boolean;
+	markdownTheme: ConstructorParameters<typeof Markdown>[3];
+	hiddenThinkingLabel: string;
+	outputPad: number;
+	lastMessage?: AssistantMessage;
+	hasToolCalls: boolean;
+	updateContent(message: AssistantMessage): void;
+};
+
+type PatchedPrototype = typeof AssistantMessageComponent.prototype & {
+	updateContent: (message: AssistantMessage) => void;
+};
+
+// 配置由 claude-code-style 管控（installCompactThinking 注入初始值，
+// updateConfig 运行时更新），上游的配置文件读写已移除。
+const config: CompactThinkingConfig = {
+	useSummaryTitlesAsThinkingTitle: true,
+	previewLines: 3,
+	animationIntervalMs: 90,
+};
+
+const DURATION_ENTRY_TYPE = "compact-thinking-duration";
+
+function restoreDurationEntries(
+	entries: Array<{ type: string; customType?: string; data?: unknown }>,
+	completedDurations: Map<number, Map<number, number>>,
+) {
+	completedDurations.clear();
+	for (const entry of entries) {
+		if (
+			entry.type !== "custom" ||
+			entry.customType !== DURATION_ENTRY_TYPE ||
+			!entry.data ||
+			typeof entry.data !== "object"
+		) {
+			continue;
+		}
+
+		const data = entry.data as Partial<DurationEntryData>;
+		if (
+			typeof data.messageTimestamp !== "number" ||
+			!Number.isFinite(data.messageTimestamp) ||
+			typeof data.contentIndex !== "number" ||
+			!Number.isInteger(data.contentIndex) ||
+			typeof data.durationMs !== "number" ||
+			!Number.isFinite(data.durationMs) ||
+			data.durationMs < 1
+		) {
+			continue;
+		}
+
+		let durations = completedDurations.get(data.messageTimestamp);
+		if (!durations) {
+			durations = new Map();
+			completedDurations.set(data.messageTimestamp, durations);
+		}
+		durations.set(data.contentIndex, data.durationMs);
 	}
+}
 
-	// Reuse Pi's live modules so the upstream prototype patch reaches runtime components.
-	const jiti = createJiti(import.meta.url, {
-		virtualModules: {
-			"@earendil-works/pi-ai": piAi,
-			"@earendil-works/pi-coding-agent": piCodingAgent,
-			"@earendil-works/pi-tui": piTui,
-		},
+function formatThoughtDuration(durationMs: number) {
+	if (durationMs < 1_000) {
+		return `${Math.max(1, Math.round(durationMs))}ms`;
+	}
+
+	const totalSeconds = Math.max(1, Math.round(durationMs / 1_000));
+	const minutes = Math.floor(totalSeconds / 60);
+	const seconds = totalSeconds % 60;
+	if (minutes === 0) return `${seconds}s`;
+	return seconds === 0 ? `${minutes}m` : `${minutes}m ${seconds}s`;
+}
+
+function getThinkingToggleHint() {
+	const keys = getKeybindings().getKeys("app.thinking.toggle");
+	return keys.length > 0 ? `${keys.join("/")} to expand` : undefined;
+}
+
+class StrictThinkingPreview implements Component {
+	private text: string;
+	private padding: number;
+	private style: (text: string) => string;
+
+	constructor(text: string, padding: number, style: (text: string) => string) {
+		this.text = text;
+		this.padding = padding;
+		this.style = style;
+	}
+
+	render(width: number) {
+		const lines = new Text(this.style(this.text), this.padding, 0).render(width);
+		if (lines.length <= config.previewLines) return lines;
+
+		const hiddenLines = lines.length - config.previewLines;
+		const noun = hiddenLines === 1 ? "line" : "lines";
+		const toggleHint = getThinkingToggleHint();
+		const hint = `... (${hiddenLines} more ${noun}${toggleHint ? `, ${toggleHint}` : ""})`;
+		const hintLines = new Text(this.style(hint), this.padding, 0).render(width);
+		return [...hintLines, ...lines.slice(-config.previewLines)];
+	}
+
+	invalidate() {}
+}
+
+function parseSummaryPart(text: string): SummaryPart | undefined {
+	const match = /^\s*\*\*([^\n]+?)\*\*[ \t]*(?:\r?\n(?:\r?\n)?([\s\S]*))?\s*$/.exec(text);
+	if (!match) return undefined;
+	return { title: match[1].trim(), body: (match[2] ?? "").trim() };
+}
+
+function parseLatestStreamingSummary(text: string): SummaryPart | undefined {
+	// Providers do not consistently insert a blank line between streamed
+	// summary parts, so accept a bold title at the start of any source line.
+	const titlePattern = /(?:^|\r?\n)\s*\*\*([^\n*]+?)\*\*[ \t]*(?:\r?\n)?/g;
+	let latest: RegExpExecArray | undefined;
+	let match: RegExpExecArray | null;
+	while ((match = titlePattern.exec(text))) latest = match;
+	if (!latest) return parseSummaryPart(text);
+
+	return {
+		title: latest[1].trim(),
+		body: text.slice(latest.index + latest[0].length).trim(),
+	};
+}
+
+function isOpenAiResponsesMessage(message: AssistantMessage) {
+	return (
+		message.api === "openai-responses" ||
+		message.api === "openai-codex-responses" ||
+		message.api === "azure-openai-responses"
+	);
+}
+
+function getLatestOpenAiSummary(thinkingSignature: string | undefined): SummaryPart | undefined {
+	if (!thinkingSignature) return undefined;
+
+	try {
+		const item = JSON.parse(thinkingSignature) as {
+			type?: unknown;
+			summary?: Array<{ type?: unknown; text?: unknown }>;
+		};
+		if (item.type !== "reasoning" || !Array.isArray(item.summary)) {
+			return undefined;
+		}
+
+		for (let i = item.summary.length - 1; i >= 0; i--) {
+			const part = item.summary[i];
+			if (part.type !== "summary_text" || typeof part.text !== "string") {
+				continue;
+			}
+			const parsed = parseSummaryPart(part.text);
+			if (parsed) return parsed;
+		}
+	} catch {
+		// Invalid or provider-specific signatures use the generic fallback.
+	}
+	return undefined;
+}
+
+const WIDGET_ID = "compact-thinking-render-loop";
+
+// 上游 index.ts 内联（含 subagent fork patch）。
+function compactThinking(pi: ExtensionAPI) {
+	const prototype = AssistantMessageComponent.prototype as PatchedPrototype;
+	const originalUpdateContent = prototype.updateContent;
+
+	const completedDurations = new Map<number, Map<number, number>>();
+	const renderedComponents = new Set<AssistantMessageComponentLike>();
+	const streamingComponents = new Set<AssistantMessageComponentLike>();
+	let activeThinking: ActiveThinking | undefined;
+	let activeTheme: Theme | undefined;
+	let activeTui: RenderTui | undefined;
+	let latestComponent: AssistantMessageComponentLike | undefined;
+	let latestComponentTimestamp: number | undefined;
+	let animationTimer: ReturnType<typeof setInterval> | undefined;
+	let animationFrame = 0;
+	let patchInstalled = true;
+
+	function refreshRenderedComponents() {
+		for (const component of renderedComponents) {
+			const self = component as unknown as AssistantInternals;
+			if (self.lastMessage) self.updateContent(self.lastMessage);
+		}
+		activeTui?.requestRender(true);
+	}
+
+	function thinkingStyle(text: string) {
+		return activeTheme ? activeTheme.italic(activeTheme.fg("thinkingText", text)) : text;
+	}
+
+	function summaryTitleStyle(text: string) {
+		return activeTheme
+			? activeTheme.italic(activeTheme.bold(activeTheme.fg("thinkingText", text)))
+			: text;
+	}
+
+	function animatedText(text: string, baseStyle: (value: string) => string, animate: boolean) {
+		if (!animate || !activeTheme) return baseStyle(text);
+
+		const characters = Array.from(text);
+		if (characters.length === 0) return "";
+		const highlightWidth = Math.max(1, Math.min(5, Math.ceil(characters.length * 0.28)));
+		const start = (animationFrame % (characters.length + highlightWidth)) - highlightWidth;
+		const end = start + highlightWidth;
+		const before = characters.slice(0, Math.max(0, start)).join("");
+		const highlighted = characters
+			.slice(Math.max(0, start), Math.min(characters.length, end))
+			.join("");
+		const after = characters.slice(Math.max(0, end)).join("");
+
+		return (
+			baseStyle(before) +
+			(highlighted
+				? activeTheme.italic(activeTheme.bold(activeTheme.fg("text", highlighted)))
+				: "") +
+			baseStyle(after)
+		);
+	}
+
+	function getCompletedDuration(messageTimestamp: number, startIndex: number, endIndex: number) {
+		const durations = completedDurations.get(messageTimestamp);
+		if (!durations) return undefined;
+		for (let index = endIndex; index >= startIndex; index--) {
+			const duration = durations.get(index);
+			if (duration !== undefined) return duration;
+		}
+		return undefined;
+	}
+
+	function isActiveRun(message: AssistantMessage, startIndex: number, endIndex: number) {
+		return (
+			activeThinking?.messageTimestamp === message.timestamp &&
+			activeThinking.contentIndex >= startIndex &&
+			activeThinking.contentIndex <= endIndex
+		);
+	}
+
+	prototype.updateContent = function patchedUpdateContent(message: AssistantMessage) {
+		const component = this as AssistantMessageComponentLike;
+		const self = this as unknown as AssistantInternals;
+		self.lastMessage = message;
+		renderedComponents.add(component);
+		latestComponent = component;
+		latestComponentTimestamp = message.timestamp;
+
+		// Visible mode is intentionally untouched: Shift+Tab restores Pi's exact
+		// built-in Thinking Markdown renderer, including every OpenAI summary stage.
+		if (!self.hideThinkingBlock) {
+			originalUpdateContent.call(this, message);
+			return;
+		}
+
+		if (activeThinking?.messageTimestamp === message.timestamp) {
+			streamingComponents.add(component);
+		}
+
+		self.contentContainer.clear();
+		const hasActiveThinking =
+			activeThinking?.messageTimestamp === message.timestamp &&
+			message.content.some((content) => content.type === "thinking");
+		const hasVisibleContent =
+			hasActiveThinking ||
+			message.content.some(
+				(content) =>
+					(content.type === "text" && content.text.trim()) ||
+					(content.type === "thinking" && content.thinking.trim()),
+			);
+		// Reserve Pi's normal leading spacer even before the first thinking token.
+		// This prevents the placeholder heading from jumping down one row when
+		// summary/body content begins streaming.
+		if (hasVisibleContent) self.contentContainer.addChild(new Spacer(1));
+
+		for (let i = 0; i < message.content.length; i++) {
+			const content = message.content[i];
+
+			if (content.type === "text" && content.text.trim()) {
+				self.contentContainer.addChild(
+					new Markdown(content.text.trim(), self.outputPad, 0, self.markdownTheme),
+				);
+				continue;
+			}
+
+			if (content.type !== "thinking") continue;
+
+			const runStartIndex = i;
+			const hasVisibleContentBefore = message.content
+				.slice(0, runStartIndex)
+				.some(
+					(previous) =>
+						(previous.type === "text" && previous.text.trim()) ||
+						(previous.type === "thinking" && previous.thinking.trim()),
+				);
+			const thinkingBlocks: string[] = [];
+			let latestSummary: SummaryPart | undefined;
+			for (; i < message.content.length; i++) {
+				const thinkingContent = message.content[i];
+				if (thinkingContent.type !== "thinking") break;
+				const thinking = thinkingContent.thinking.trim();
+				if (!thinking) continue;
+				thinkingBlocks.push(thinking);
+
+				if (config.useSummaryTitlesAsThinkingTitle && isOpenAiResponsesMessage(message)) {
+					const contentIsActive =
+						activeThinking?.messageTimestamp === message.timestamp &&
+						activeThinking.contentIndex === i;
+					// During streaming, thinkingSignature may contain only the previously
+					// completed summary parts. Prefer the live text so a newly arriving
+					// title immediately replaces the old one instead of appearing in its
+					// preview body. Once complete, the structured signature is canonical.
+					latestSummary = contentIsActive
+						? (parseLatestStreamingSummary(thinking) ??
+							getLatestOpenAiSummary(thinkingContent.thinkingSignature) ??
+							latestSummary)
+						: (getLatestOpenAiSummary(thinkingContent.thinkingSignature) ??
+							parseLatestStreamingSummary(thinking) ??
+							latestSummary);
+				}
+			}
+			const runEndIndex = i - 1;
+			i--;
+			const active = isActiveRun(message, runStartIndex, runEndIndex);
+			// OpenAI can spend several seconds reasoning before it emits the first
+			// summary token. Keep an empty active block visible as animated
+			// "Thinking..." during that otherwise silent interval.
+			if (thinkingBlocks.length === 0 && !active) continue;
+			if (hasVisibleContentBefore) {
+				self.contentContainer.addChild(new Spacer(1));
+			}
+
+			const elapsedMs = activeThinking
+				? Math.max(1, Date.now() - activeThinking.startedAt)
+				: undefined;
+			const completedMs = getCompletedDuration(message.timestamp, runStartIndex, runEndIndex);
+			const durationMs = active ? elapsedMs : completedMs;
+			const durationText = durationMs === undefined ? undefined : formatThoughtDuration(durationMs);
+
+			let heading: string;
+			if (active && latestSummary) {
+				heading =
+					animatedText(latestSummary.title, summaryTitleStyle, true) +
+					(durationText ? thinkingStyle(` · ${durationText}`) : "");
+			} else if (active) {
+				const label = self.hiddenThinkingLabel || "Thinking...";
+				heading =
+					animatedText(label, thinkingStyle, true) +
+					(durationText ? thinkingStyle(` · ${durationText}`) : "");
+			} else {
+				// Completed compact blocks use one provider-independent status line.
+				heading = thinkingStyle(
+					durationText ? `Thought for ${durationText}` : self.hiddenThinkingLabel || "Thinking...",
+				);
+			}
+			self.contentContainer.addChild(new Text(heading, self.outputPad, 0));
+
+			const previewSource = latestSummary?.body ?? thinkingBlocks.join("\n\n");
+			if (config.previewLines > 0 && previewSource.trim()) {
+				self.contentContainer.addChild(
+					new StrictThinkingPreview(previewSource.trim(), self.outputPad, thinkingStyle),
+				);
+			}
+
+			const hasVisibleContentAfter = message.content
+				.slice(i + 1)
+				.some(
+					(next) =>
+						(next.type === "text" && next.text.trim()) ||
+						(next.type === "thinking" && next.thinking.trim()),
+				);
+			if (hasVisibleContentAfter) self.contentContainer.addChild(new Spacer(1));
+		}
+
+		const hasToolCalls = message.content.some((content) => content.type === "toolCall");
+		self.hasToolCalls = hasToolCalls;
+
+		if (message.stopReason === "length") {
+			self.contentContainer.addChild(new Spacer(1));
+			self.contentContainer.addChild(
+				new Text(
+					activeTheme
+						? activeTheme.fg(
+								"error",
+								"Error: Model stopped because it reached the maximum output token limit. The response may be incomplete.",
+							)
+						: "Error: Model stopped because it reached the maximum output token limit. The response may be incomplete.",
+					self.outputPad,
+					0,
+				),
+			);
+		} else if (!hasToolCalls) {
+			if (message.stopReason === "aborted") {
+				const abortMessage =
+					message.errorMessage && message.errorMessage !== "Request was aborted"
+						? message.errorMessage
+						: "Operation aborted";
+				self.contentContainer.addChild(new Spacer(1));
+				self.contentContainer.addChild(
+					new Text(
+						activeTheme ? activeTheme.fg("error", abortMessage) : abortMessage,
+						self.outputPad,
+						0,
+					),
+				);
+			} else if (message.stopReason === "error") {
+				const errorMessage = message.errorMessage || "Unknown error";
+				self.contentContainer.addChild(new Spacer(1));
+				self.contentContainer.addChild(
+					new Text(
+						activeTheme
+							? activeTheme.fg("error", `Error: ${errorMessage}`)
+							: `Error: ${errorMessage}`,
+						self.outputPad,
+						0,
+					),
+				);
+			}
+		}
+	};
+
+	function startThinking(message: AssistantMessage, contentIndex: number) {
+		activeThinking = {
+			messageTimestamp: message.timestamp,
+			contentIndex,
+			startedAt: Date.now(),
+		};
+		streamingComponents.clear();
+		animationFrame = 0;
+
+		// Depending on event-listener order, Pi may have rendered the empty
+		// thinking_start partial just before this extension receives the event.
+		// Re-render that component immediately so users do not wait for the first
+		// summary delta before seeing the animation.
+		if (latestComponent && latestComponentTimestamp === message.timestamp) {
+			streamingComponents.add(latestComponent);
+			const self = latestComponent as unknown as AssistantInternals;
+			self.updateContent(message);
+			activeTui?.requestRender();
+		}
+
+		if (animationTimer) clearInterval(animationTimer);
+		animationTimer = setInterval(() => {
+			animationFrame++;
+			for (const component of streamingComponents) {
+				const self = component as unknown as AssistantInternals;
+				if (self.lastMessage) self.updateContent(self.lastMessage);
+			}
+			activeTui?.requestRender();
+		}, config.animationIntervalMs);
+	}
+
+	function finishThinking() {
+		if (!activeThinking) return;
+		const finished = activeThinking;
+		const durationMs = Math.max(1, Date.now() - finished.startedAt);
+		let durations = completedDurations.get(finished.messageTimestamp);
+		if (!durations) {
+			durations = new Map();
+			completedDurations.set(finished.messageTimestamp, durations);
+		}
+		durations.set(finished.contentIndex, durationMs);
+		pi.appendEntry(DURATION_ENTRY_TYPE, {
+			messageTimestamp: finished.messageTimestamp,
+			contentIndex: finished.contentIndex,
+			durationMs,
+		} as DurationEntryData);
+
+		activeThinking = undefined;
+		if (animationTimer) clearInterval(animationTimer);
+		animationTimer = undefined;
+
+		const components = [...streamingComponents];
+		streamingComponents.clear();
+		for (const component of components) {
+			const self = component as unknown as AssistantInternals;
+			if (self.lastMessage) self.updateContent(self.lastMessage);
+		}
+		activeTui?.requestRender();
+	}
+
+	// ---- fork patch：subagent 工具执行期间保持思考动画 ----
+
+	// Subagent tools can run for minutes: keep the thinking loading animation
+	// alive for the whole execution and only finalize once the tool ends or the
+	// model emits the next text/thinking boundary.
+	function resumeAgentThinking(message: AssistantMessage | undefined) {
+		if (activeThinking) return;
+		const content = message?.content;
+		if (!Array.isArray(content)) return;
+		const index = content.findIndex((item) => item?.type === "thinking");
+		if (index < 0) return;
+		startThinking(message as AssistantMessage, index);
+	}
+
+	function messageHasAgentTool(message: AssistantMessage | undefined) {
+		return (
+			Array.isArray(message?.content) &&
+			message.content.some(
+				(content) =>
+					content?.type === "toolCall" &&
+					(content.name === "Agent" ||
+						content.name === "Agents" ||
+						content.args?.subagent_type != null),
+			)
+		);
+	}
+
+	pi.on("message_update", (event) => {
+		if (event.message.role !== "assistant") return;
+		const update = event.assistantMessageEvent;
+
+		if (update.type === "thinking_start") {
+			if (activeThinking?.messageTimestamp === event.message.timestamp) {
+				// Some Responses-compatible providers emit a fresh thinking_start for
+				// each summary/reasoning item even though no text or tool boundary has
+				// ended the visible Thinking run. Follow the new content block without
+				// resetting the run's original start time.
+				activeThinking.contentIndex = update.contentIndex;
+			} else {
+				if (activeThinking) finishThinking();
+				startThinking(event.message, update.contentIndex);
+			}
+		} else if (update.type === "thinking_delta") {
+			if (!activeThinking) {
+				startThinking(event.message, update.contentIndex);
+			} else if (activeThinking.messageTimestamp === event.message.timestamp) {
+				activeThinking.contentIndex = update.contentIndex;
+			}
+		} else if (update.type === "text_start") {
+			finishThinking();
+		} else if (update.type === "toolcall_start" || update.type === "toolcall_delta") {
+			if (messageHasAgentTool(event.message)) {
+				resumeAgentThinking(event.message);
+			} else {
+				finishThinking();
+			}
+		}
+		// Do not finalize on thinking_end alone. OpenAI Responses providers can
+		// close one reasoning item and immediately open another for the next
+		// summary while Pi still renders both as one contiguous Thinking run.
+		// A text/tool transition or message_end is the actual visible boundary.
+	});
+
+	// OpenAI-compatible providers may not close reasoning until the response ends.
+	pi.on("tool_execution_start", (event: any) => {
+		if (event.toolName === "Agent" || event.toolName === "Agents") {
+			resumeAgentThinking(latestComponent?.lastMessage ?? undefined);
+		} else {
+			finishThinking();
+		}
+	});
+	pi.on("tool_execution_end", (event: any) => {
+		if (event.toolName === "Agent" || event.toolName === "Agents") finishThinking();
+	});
+	pi.on("message_end", (event) => {
+		if (event.message.role !== "assistant") return;
+		// Agent tool runs after message_end; keep the ticker until tool_execution_end
+		// or the next text/thinking boundary.
+		if (messageHasAgentTool(event.message)) return;
+		finishThinking();
+	});
+
+	pi.on("session_start", (_event, ctx) => {
+		restoreDurationEntries(ctx.sessionManager.getBranch(), completedDurations);
+		activeTheme = ctx.ui.theme;
+		if (ctx.mode !== "tui") return;
+
+		// An empty widget gives the animation loop access to requestRender without
+		// enabling terminal mouse reporting or intercepting native scrollback input.
+		ctx.ui.setWidget(WIDGET_ID, (tui) => {
+			activeTui = tui;
+			return { render: () => [], invalidate() {} };
+		});
+
+		// On resume, Pi may construct the chat before session_start is emitted.
+		// Rebuild those already-rendered components now that persisted durations
+		// and the active theme are available.
+		refreshRenderedComponents();
+	});
+
+	pi.on("session_tree", (_event, ctx) => {
+		restoreDurationEntries(ctx.sessionManager.getBranch(), completedDurations);
+		refreshRenderedComponents();
+	});
+
+	pi.on("session_shutdown", (_event, ctx) => {
+		finishThinking();
+		if (animationTimer) clearInterval(animationTimer);
+		animationTimer = undefined;
+		activeTui = undefined;
+		activeTheme = undefined;
+		latestComponent = undefined;
+		latestComponentTimestamp = undefined;
+		completedDurations.clear();
+		renderedComponents.clear();
+		streamingComponents.clear();
+		if (ctx.mode === "tui") ctx.ui.setWidget(WIDGET_ID, undefined);
+
+		if (patchInstalled) {
+			prototype.updateContent = originalUpdateContent;
+			patchInstalled = false;
+		}
 	});
-	const upstreamConfig = (
-		jiti("pi-compact-thinking/lib/config.ts") as { config: CompactThinkingConfig }
-	).config;
-	const compactThinking = (
-		jiti.evalModule(upstreamIndexSource, { filename: upstreamIndexPath }) as {
-			default: (api: ExtensionAPI) => void;
-		}
-	).default;
-	return { config: upstreamConfig, compactThinking };
 }
 
+type CompactThinkingOwner = {
+	owner: object;
+	stop(event?: any, ctx?: any): void;
+};
+
+const COMPACT_THINKING_OWNER = Symbol.for("pi.ccstyle.compact-thinking-owner");
+
+type UpstreamHandler = (event: any, ctx: any) => void;
+
 export function installCompactThinking(
 	pi: ExtensionAPI,
 	initialConfig: CompactThinkingConfig,
@@ -141,7 +673,6 @@ export function installCompactThinking(
 		[COMPACT_THINKING_OWNER]?: CompactThinkingOwner;
 	};
 
-	let upstreamConfig: CompactThinkingConfig | undefined;
 	let session: { event: any; ctx: any } | undefined;
 	let active = false;
 	// Stable pi.on wrappers delegate here so activate/reload never double-binds.
@@ -188,22 +719,11 @@ export function installCompactThinking(
 		host[COMPACT_THINKING_OWNER]?.stop(event, ctx);
 		session = { event, ctx };
 
-		// compact-thinking.json 已日落：不预写、不读取，配置统一由
-		// claude-code-style.json 管控（下方 Object.assign 覆盖库默认值）。
-		// 库首次加载会在 .pi/agent 下自建默认文件，加载完成后立即删除，不留残留。
-		const agentDir = process.env.PI_CODING_AGENT_DIR ?? join(homedir(), ".pi", "agent");
-		const configPath = join(agentDir, "compact-thinking.json");
-		let loaded: ReturnType<typeof loadPatchedUpstream>;
-		try {
-			loaded = loadPatchedUpstream();
-		} finally {
-			rmSync(configPath, { force: true });
-		}
-		upstreamConfig = loaded.config;
-		Object.assign(upstreamConfig, initialConfig);
+		// 配置统一由 claude-code-style 管控，加载时覆盖库默认值。
+		Object.assign(config, initialConfig);
 		delegates.clear();
 
-		loaded.compactThinking({
+		compactThinking({
 			on(eventName: string, handler: UpstreamHandler) {
 				if (eventName === "session_start") {
 					// Already inside session_start — run immediately.
@@ -236,7 +756,7 @@ export function installCompactThinking(
 	return {
 		updateConfig(next) {
 			Object.assign(initialConfig, next);
-			if (upstreamConfig) Object.assign(upstreamConfig, next);
+			Object.assign(config, next);
 		},
 	};
 }

package/extensions/fixed-editor.ts

@@ -8,18 +8,6 @@ import { createJiti } from "jiti";
 type LifecycleHandler = (event: any, ctx: any) => void;
 type FixedEditorExtension = (pi: ExtensionAPI) => void;
 
-// Upstream publishes TS only. Nested jiti must reuse Pi's live modules — peer
-// deps are not resolvable from ~/.pi/agent/npm/node_modules/pi-cc-extensions.
-const jiti = createJiti(import.meta.url, {
-	virtualModules: {
-		"@earendil-works/pi-coding-agent": piCodingAgent,
-		"@earendil-works/pi-tui": piTui,
-	},
-});
-// Match pi-fixed-editor's own `.js` import specifier; Jiti caches `.ts` separately.
-const terminalSplit = jiti("@tifan/pi-fixed-editor/src/terminal-split.js") as {
-	TerminalSplitCompositor?: { prototype: Record<PropertyKey, any> };
-};
 export type FixedEditorHitbox = { row: number; startCol: number; endCol: number };
 export type FixedEditorViewportSnapshot = {
 	tui: object;
@@ -61,48 +49,104 @@ function clearFixedEditorViewport(): void {
 	fixedEditorState.viewports = new WeakMap();
 }
 
-const FIXED_EDITOR_SPACING_PATCH = Symbol.for("pi.ccstyle.fixed-editor-spacing-patch");
-const clusterModule = jiti("@tifan/pi-fixed-editor/src/cluster.js") as {
-	renderFixedEditorCluster?: (input: any) => any;
+type UpstreamFixedEditor = {
+	start?: LifecycleHandler;
+	shutdown?: LifecycleHandler;
 };
-if (!(clusterModule as any)[FIXED_EDITOR_SPACING_PATCH] && clusterModule.renderFixedEditorCluster) {
-	const renderCluster = clusterModule.renderFixedEditorCluster;
-	const padWidgets = (lines: string[] | undefined) =>
-		lines?.map((line) => (line.length > 0 && !line.includes("Ctrl+End") ? ` ${line}` : line));
-	clusterModule.renderFixedEditorCluster = (input) => {
-		const aboveWidgetLines = padWidgets(input.aboveWidgetLines);
-		const result = renderCluster({
-			...input,
-			// pi-fixed-editor strips Pi's leading widget spacer; restore it below the spinner.
-			aboveWidgetLines:
-				input.statusLines?.length && aboveWidgetLines?.length
-					? ["", ...aboveWidgetLines]
-					: aboveWidgetLines,
-			belowWidgetLines: padWidgets(input.belowWidgetLines),
+
+// 上游按需加载：0.84+ 的 tui 是惰性 Proxy（installFixedEditor 用
+// isLazyProxySession 探测），fixed-editor 整体停用 —— 连上游包都不解析，
+// jiti 失败或包缺失都不影响主流程。
+let upstreamLoaded = false;
+let upstream: UpstreamFixedEditor | undefined;
+function loadUpstream(): UpstreamFixedEditor | undefined {
+	if (upstreamLoaded) return upstream;
+	upstreamLoaded = true;
+	try {
+		// Upstream publishes TS only. Nested jiti must reuse Pi's live modules — peer
+		// deps are not resolvable from ~/.pi/agent/npm/node_modules/pi-cc-extensions.
+		const jiti = createJiti(import.meta.url, {
+			virtualModules: {
+				"@earendil-works/pi-coding-agent": piCodingAgent,
+				"@earendil-works/pi-tui": piTui,
+			},
 		});
-		const buttonRow = result.lines.findIndex((line: string) => line.includes("Ctrl+End"));
-		if (buttonRow < 0) {
-			fixedEditorState.scrollButtonHitbox = null;
-		} else {
-			const plain = result.lines[buttonRow]
-				.replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, "")
-				.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "");
-			const start = plain.indexOf("[");
-			fixedEditorState.scrollButtonHitbox = {
-				row: input.terminalRows - result.lines.length + buttonRow + 1,
-				startCol: visibleWidth(plain.slice(0, Math.max(0, start))) + 1,
-				endCol: visibleWidth(plain.trimEnd()),
+		// Match pi-fixed-editor's own `.js` import specifier; Jiti caches `.ts` separately.
+		const terminalSplit = jiti("@tifan/pi-fixed-editor/src/terminal-split.js") as {
+			TerminalSplitCompositor?: { prototype: Record<PropertyKey, any> };
+		};
+
+		const FIXED_EDITOR_SPACING_PATCH = Symbol.for("pi.ccstyle.fixed-editor-spacing-patch");
+		const clusterModule = jiti("@tifan/pi-fixed-editor/src/cluster.js") as {
+			renderFixedEditorCluster?: (input: any) => any;
+		};
+		if (
+			!(clusterModule as any)[FIXED_EDITOR_SPACING_PATCH] &&
+			clusterModule.renderFixedEditorCluster
+		) {
+			const renderCluster = clusterModule.renderFixedEditorCluster;
+			const padWidgets = (lines: string[] | undefined) =>
+				lines?.map((line) => (line.length > 0 && !line.includes("Ctrl+End") ? ` ${line}` : line));
+			clusterModule.renderFixedEditorCluster = (input) => {
+				const aboveWidgetLines = padWidgets(input.aboveWidgetLines);
+				const result = renderCluster({
+					...input,
+					// pi-fixed-editor strips Pi's leading widget spacer; restore it below the spinner.
+					aboveWidgetLines:
+						input.statusLines?.length && aboveWidgetLines?.length
+							? ["", ...aboveWidgetLines]
+							: aboveWidgetLines,
+					belowWidgetLines: padWidgets(input.belowWidgetLines),
+				});
+				const buttonRow = result.lines.findIndex((line: string) => line.includes("Ctrl+End"));
+				if (buttonRow < 0) {
+					fixedEditorState.scrollButtonHitbox = null;
+				} else {
+					const plain = result.lines[buttonRow]
+						.replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, "")
+						.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "");
+					const start = plain.indexOf("[");
+					fixedEditorState.scrollButtonHitbox = {
+						row: input.terminalRows - result.lines.length + buttonRow + 1,
+						startCol: visibleWidth(plain.slice(0, Math.max(0, start))) + 1,
+						endCol: visibleWidth(plain.trimEnd()),
+					};
+				}
+				return result;
 			};
+			(clusterModule as any)[FIXED_EDITOR_SPACING_PATCH] = true;
 		}
-		return result;
-	};
-	(clusterModule as any)[FIXED_EDITOR_SPACING_PATCH] = true;
+		const loaded = jiti("@tifan/pi-fixed-editor/src/index.ts") as {
+			default?: FixedEditorExtension;
+		};
+		const fixedEditor = loaded.default ?? (loaded as unknown as FixedEditorExtension);
+
+		if (terminalSplit.TerminalSplitCompositor) {
+			installFixedEditorImePatch(terminalSplit.TerminalSplitCompositor);
+			// 0.84+ 的 tui 是惰性 Proxy：compositor 构造时捕获的 doRender/render 是
+			// 每次重新解析的包装，install 后执行会解析到 compositor 自身（无限递归）。
+			// 检测到惰性 Proxy 时跳过安装，渲染管线完全交给官方。
+			installProxyGuard(terminalSplit.TerminalSplitCompositor);
+		}
+
+		let start: LifecycleHandler | undefined;
+		let shutdown: LifecycleHandler | undefined;
+		fixedEditor({
+			on(event: string, handler: LifecycleHandler) {
+				if (event === "session_start") start = handler;
+				if (event === "session_shutdown") shutdown = handler;
+			},
+		} as unknown as ExtensionAPI);
+
+		upstream = { start, shutdown };
+	} catch (error) {
+		console.error("pi-cc-extensions: failed to load @tifan/pi-fixed-editor", error);
+		upstream = undefined;
+	}
+	return upstream;
 }
-const loaded = jiti("@tifan/pi-fixed-editor/src/index.ts") as {
-	default?: FixedEditorExtension;
-};
-const fixedEditor = loaded.default ?? (loaded as unknown as FixedEditorExtension);
 
+const COMPOSITOR_PROXY_GUARD = Symbol.for("pi.ccstyle.compositor-proxy-guard");
 const IME_CURSOR_PATCH = Symbol.for("pi.ccstyle.fixed-editor-ime-cursor-patch");
 const VIEWPORT_PATCH = Symbol.for("pi.ccstyle.fixed-editor-viewport-patch");
 const MOUSE_WRITE_PATCH = Symbol.for("pi.ccstyle.fixed-editor-mouse-write-patch");
@@ -197,16 +241,6 @@ export function installFixedEditorImePatch(compositorClass: {
 	}
 }
 
-const COMPOSITOR_PROXY_GUARD = Symbol.for("pi.ccstyle.compositor-proxy-guard");
-
-if (terminalSplit.TerminalSplitCompositor) {
-	installFixedEditorImePatch(terminalSplit.TerminalSplitCompositor);
-	// 0.84+ 的 tui 是惰性 Proxy：compositor 构造时捕获的 doRender/render 是
-	// 每次重新解析的包装，install 后执行会解析到 compositor 自身（无限递归）。
-	// 检测到惰性 Proxy 时跳过安装，渲染管线完全交给官方。
-	installProxyGuard(terminalSplit.TerminalSplitCompositor);
-}
-
 function installProxyGuard(compositorClass: { prototype: Record<PropertyKey, any> }): void {
 	const prototype = compositorClass.prototype;
 	const originalInstall = prototype.install;
@@ -277,20 +311,41 @@ function observeFooterReplacement(ui: any, listener: () => void): () => void {
 	};
 }
 
+const LAZY_PROXY_PROBE_KEY = "cc-lazy-proxy-probe";
+
+/**
+ * 测试钩子：会话未激活时直接加载上游。懒加载下 patch 仅在 activate 时执行，
+ * 直接 new 上游 compositor / 调用上游 cluster 的测试需要显式触发。
+ */
+export function loadFixedEditorUpstreamForTests(): void {
+	loadUpstream();
+}
+
+/** 探测当前会话的 TUI 是否为 0.84+ 惰性 Proxy（与 isFullscreenUi 同模式）。 */
+function isLazyProxySession(ctx: any): boolean {
+	if (typeof ctx?.ui?.setWidget !== "function") return false;
+	let proxyTui = false;
+	try {
+		ctx.ui.setWidget(LAZY_PROXY_PROBE_KEY, (tui: any) => {
+			proxyTui = isLazyProxyTui(tui);
+			return { render: () => [], invalidate() {} };
+		});
+	} catch {
+		// 探测失败按 regular 处理，避免误伤
+	}
+	try {
+		ctx.ui.setWidget(LAZY_PROXY_PROBE_KEY, undefined);
+	} catch {
+		// 忽略
+	}
+	return proxyTui;
+}
+
 /** Adds runtime on/off control around pi-fixed-editor's session lifecycle. */
 export function installFixedEditor(
 	pi: ExtensionAPI,
 	initiallyEnabled: boolean,
 ): FixedEditorController {
-	let start: LifecycleHandler | undefined;
-	let shutdown: LifecycleHandler | undefined;
-	fixedEditor({
-		on(event: string, handler: LifecycleHandler) {
-			if (event === "session_start") start = handler;
-			if (event === "session_shutdown") shutdown = handler;
-		},
-	} as unknown as ExtensionAPI);
-
 	const owner = {};
 	let enabled = initiallyEnabled;
 	let active = false;
@@ -340,6 +395,11 @@ export function installFixedEditor(
 		if (!session || session.ctx?.mode !== "tui" || active) return;
 		// fullscreen 复用官方的 sticky editor，固定编辑器让位
 		if (isFullscreenUi(session.ctx)) return;
+		// 0.84+ 的 tui 是惰性 Proxy：fixed-editor 整体停用，不加载上游包。
+		if (isLazyProxySession(session.ctx)) return;
+		const loadedUpstream = loadUpstream();
+		if (!loadedUpstream?.start || !loadedUpstream.shutdown) return;
+		const { start, shutdown } = loadedUpstream;
 		const previous = (globalThis as any)[FIXED_EDITOR_OWNER] as FixedEditorOwner | undefined;
 		if (previous?.owner !== owner) previous?.stop();
 		const currentSession = session;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-cc-extensions",
-	"version": "0.8.43",
+	"version": "0.8.45",
 	"license": "MIT",
 	"description": "A Pi productivity suite with Claude Code-style UI, fixed editor, context inspection, and agent/session references",
 	"type": "module",
@@ -31,7 +31,8 @@
 			"./extensions/index.ts"
 		],
 		"themes": [
-			"./themes/github-dark-default.json"
+			"./themes/github-dark-default.json",
+			"./themes/cc-dark.json"
 		],
 		"image": "https://raw.githubusercontent.com/minuque/pi-cc-extensions/main/assets/readme/welcome.webp"
 	},
@@ -48,8 +49,7 @@
 	"dependencies": {
 		"@shikijs/cli": "^4.0.2",
 		"@tifan/pi-fixed-editor": "^0.2.5",
-		"jiti": "^2.7.0",
-		"pi-compact-thinking": "^0.2.0"
+		"jiti": "^2.7.0"
 	},
 	"bundledDependencies": [
 		"@tifan/pi-fixed-editor"
@@ -65,5 +65,8 @@
 	"devDependencies": {
 		"@biomejs/biome": "2.5.5",
 		"@types/node": "^26.1.1"
-	}
+	},
+	"bundleDependencies": [
+		"@tifan/pi-fixed-editor"
+	]
 }

package/themes/cc-dark.json

@@ -0,0 +1,96 @@
+{
+	"$schema": "https://raw.githubusercontent.com/earendil-works/pi/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
+	"name": "cc-dark",
+	"vars": {
+		"bg": "#131217",
+		"panel": "#1b1922",
+		"surface": "#211e2b",
+		"surfaceRaised": "#292533",
+		"border": "#36313f",
+		"borderMuted": "#292631",
+		"accent": "#5e9cff",
+		"accentBright": "#8ab4ff",
+		"purple": "#c084fc",
+		"pink": "#f472b6",
+		"cyan": "#67e8f9",
+		"blue": "#60a5fa",
+		"green": "#4ade80",
+		"red": "#fb7185",
+		"yellow": "#facc15",
+		"orange": "#fb923c",
+		"text": "#f5f5f5",
+		"muted": "#a1a1aa",
+		"dim": "#71717a",
+		"selectedBg": "#252035",
+		"userMessageBg": "#1d1a27",
+		"toolPendingBg": "#1b1924",
+		"toolSuccessBg": "#18251f",
+		"toolErrorBg": "#2a1b22",
+		"customMessageBg": "#211c30"
+	},
+	"colors": {
+		"accent": "accent",
+		"border": "border",
+		"borderAccent": "accent",
+		"borderMuted": "borderMuted",
+		"success": "green",
+		"error": "red",
+		"warning": "yellow",
+		"muted": "muted",
+		"dim": "dim",
+		"text": "text",
+		"thinkingText": "muted",
+
+		"selectedBg": "selectedBg",
+		"userMessageBg": "userMessageBg",
+		"userMessageText": "text",
+		"customMessageBg": "customMessageBg",
+		"customMessageText": "text",
+		"customMessageLabel": "purple",
+		"toolPendingBg": "toolPendingBg",
+		"toolSuccessBg": "toolSuccessBg",
+		"toolErrorBg": "toolErrorBg",
+		"toolTitle": "accentBright",
+		"toolOutput": "muted",
+
+		"mdHeading": "accentBright",
+		"mdLink": "cyan",
+		"mdLinkUrl": "muted",
+		"mdCode": "accentBright",
+		"mdCodeBlock": "text",
+		"mdCodeBlockBorder": "border",
+		"mdQuote": "muted",
+		"mdQuoteBorder": "accent",
+		"mdHr": "borderMuted",
+		"mdListBullet": "accent",
+
+		"toolDiffAdded": "green",
+		"toolDiffRemoved": "red",
+		"toolDiffContext": "muted",
+
+		"syntaxComment": "#6b7280",
+		"syntaxKeyword": "pink",
+		"syntaxFunction": "accentBright",
+		"syntaxVariable": "blue",
+		"syntaxString": "green",
+		"syntaxNumber": "orange",
+		"syntaxType": "cyan",
+		"syntaxOperator": "text",
+		"syntaxPunctuation": "muted",
+
+		"thinkingOff": "muted",
+		"thinkingMinimal": "dim",
+		"thinkingLow": "blue",
+		"thinkingMedium": "accent",
+		"thinkingHigh": "accentBright",
+		"thinkingXhigh": "cyan",
+		"thinkingMax": "purple",
+
+		"bashMode": "accent"
+	},
+	"export": {
+		"pageBg": "bg",
+		"cardBg": "panel",
+		"infoBg": "surface"
+	}
+}