pi-cc-extensions 0.8.51 → 0.8.53

package/extensions/feature/compact-thinking.ts

@@ -13,6 +13,14 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import { getKeybindings } from "@earendil-works/pi-tui";
 import { Markdown, Spacer, Text, type Component } from "@earendil-works/pi-tui";
+import {
+	animateCompactThinkingText,
+	formatThoughtDuration,
+	styleCompactThinkingText,
+} from "../renderer/compact-mode.ts";
+import { refreshMountedTranscript } from "../renderer/transcript-refresh.ts";
+// 保持导出兼容：渲染函数已并入 renderer/compact-mode.ts，这里 re-export。
+export { animateCompactThinkingText, formatThoughtDuration, styleCompactThinkingText };
 
 // pi-tui 类型声明中 TUI 的 re-export 解析失败，本地用最小结构化类型（只用到 requestRender）。
 type RenderTui = { requestRender(force?: boolean): void };
@@ -28,6 +36,18 @@ export type CompactThinkingConfig = {
 
 export type CompactThinkingController = {
 	updateConfig(next: CompactThinkingConfig): void;
+	/**
+	 * 只读查询：某条 assistant message 的可见思考总时长（ms）。
+	 * 供 compact 渲染层生成 `Thought for 8s` 摘要，不建立第二套计时器。
+	 * 无记录且无进行中思考时返回 undefined。
+	 */
+	getMessageThinkingDurationMs?(messageTimestamp: number): number | undefined;
+	/** 当前消息是否仍处于 compact-thinking 的活动思考态。 */
+	isMessageThinkingActive?(messageTimestamp: number): boolean;
+	/** 复用 compact-thinking 配置的动画帧，不建立独立动画计时器。 */
+	getThinkingAnimationFrame?(): number;
+	/** compact 摘要保持 loading 时复用 compact-thinking 的动画循环。 */
+	setCompactSummaryActive?(active: boolean): void;
 };
 
 type DurationEntryData = {
@@ -86,6 +106,16 @@ const config: CompactThinkingConfig = {
 };
 
 const DURATION_ENTRY_TYPE = "compact-thinking-duration";
+const COMPACT_THINKING_PATCH_KEY = Symbol.for("pi.ccstyle.compact-thinking-update");
+const PROTOTYPE_ORIGINAL_KEY = Symbol.for("pi.ccstyle.prototype-original");
+
+/** 当前激活 session 的只读查询委托（compact 渲染层使用）。 */
+type ThinkingDurationQuery = (messageTimestamp: number) => number | undefined;
+type ThinkingActiveQuery = (messageTimestamp: number) => boolean;
+let activeThinkingQuery: ThinkingDurationQuery | undefined;
+let activeThinkingStateQuery: ThinkingActiveQuery | undefined;
+let activeThinkingAnimationFrameQuery: (() => number) | undefined;
+let activeCompactSummarySetter: ((active: boolean) => void) | undefined;
 
 function restoreDurationEntries(
 	entries: Array<{ type: string; customType?: string; data?: unknown }>,
@@ -124,18 +154,6 @@ function restoreDurationEntries(
 	}
 }
 
-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;
@@ -253,8 +271,22 @@ function compactThinking(pi: ExtensionAPI) {
 	const prototype = AssistantMessageComponent.prototype as PatchedPrototype;
 	const originalUpdateContent = prototype.updateContent;
 
+	activeThinkingStateQuery = (messageTimestamp) =>
+		activeThinking?.messageTimestamp === messageTimestamp;
+	activeThinkingAnimationFrameQuery = () => animationFrame;
+	activeThinkingQuery = (messageTimestamp) => {
+		let total = 0;
+		const durations = completedDurations.get(messageTimestamp);
+		if (durations) {
+			for (const duration of durations.values()) total += duration;
+		}
+		if (activeThinking?.messageTimestamp === messageTimestamp) {
+			total += Math.max(1, Date.now() - activeThinking.startedAt);
+		}
+		return total > 0 ? total : undefined;
+	};
+
 	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;
@@ -263,46 +295,24 @@ function compactThinking(pi: ExtensionAPI) {
 	let latestComponentTimestamp: number | undefined;
 	let animationTimer: ReturnType<typeof setInterval> | undefined;
 	let animationFrame = 0;
+	let compactSummaryActive = false;
 	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;
+		return styleCompactThinkingText(text, activeTheme);
 	}
 
 	function summaryTitleStyle(text: string) {
-		return activeTheme
-			? activeTheme.italic(activeTheme.bold(activeTheme.fg("thinkingText", text)))
-			: text;
+		return styleCompactThinkingText(text, activeTheme, true);
 	}
 
 	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)
+		if (!animate) return baseStyle(text);
+		return animateCompactThinkingText(
+			text,
+			activeTheme,
+			animationFrame,
+			baseStyle === summaryTitleStyle,
 		);
 	}
 
@@ -328,7 +338,6 @@ function compactThinking(pi: ExtensionAPI) {
 		const component = this as AssistantMessageComponentLike;
 		const self = this as unknown as AssistantInternals;
 		self.lastMessage = message;
-		renderedComponents.add(component);
 		latestComponent = component;
 		latestComponentTimestamp = message.timestamp;
 
@@ -437,8 +446,10 @@ function compactThinking(pi: ExtensionAPI) {
 					(durationText ? thinkingStyle(` · ${durationText}`) : "");
 			} else {
 				// Completed compact blocks use one provider-independent status line.
+				// 无时长记录（中断流/旧会话/entry 缺失或索引错位）时不回退到加载文案
+				// "Thinking..."：改用摘要标题或中性 "Thought"。
 				heading = thinkingStyle(
-					durationText ? `Thought for ${durationText}` : self.hiddenThinkingLabel || "Thinking...",
+					durationText ? `Thought for ${durationText}` : (latestSummary?.title ?? "Thought"),
 				);
 			}
 			self.contentContainer.addChild(new Text(heading, self.outputPad, 0));
@@ -506,6 +517,33 @@ function compactThinking(pi: ExtensionAPI) {
 			}
 		}
 	};
+	const installedUpdateContent = prototype.updateContent;
+	(installedUpdateContent as any)[COMPACT_THINKING_PATCH_KEY] = true;
+
+	function ensureAnimationTimer() {
+		if (animationTimer) return;
+		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 stopAnimationTimerIfIdle() {
+		if (activeThinking || compactSummaryActive || !animationTimer) return;
+		clearInterval(animationTimer);
+		animationTimer = undefined;
+	}
+
+	activeCompactSummarySetter = (active) => {
+		compactSummaryActive = active;
+		if (active) ensureAnimationTimer();
+		else stopAnimationTimerIfIdle();
+		activeTui?.requestRender();
+	};
 
 	function startThinking(message: AssistantMessage, contentIndex: number) {
 		activeThinking = {
@@ -528,14 +566,8 @@ function compactThinking(pi: ExtensionAPI) {
 		}
 
 		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);
+		animationTimer = undefined;
+		ensureAnimationTimer();
 	}
 
 	function finishThinking() {
@@ -555,8 +587,7 @@ function compactThinking(pi: ExtensionAPI) {
 		} as DurationEntryData);
 
 		activeThinking = undefined;
-		if (animationTimer) clearInterval(animationTimer);
-		animationTimer = undefined;
+		stopAnimationTimerIfIdle();
 
 		const components = [...streamingComponents];
 		streamingComponents.clear();
@@ -589,7 +620,7 @@ function compactThinking(pi: ExtensionAPI) {
 					content?.type === "toolCall" &&
 					(content.name === "Agent" ||
 						content.name === "Agents" ||
-						content.args?.subagent_type != null),
+						content.arguments?.subagent_type != null),
 			)
 		);
 	}
@@ -633,7 +664,9 @@ function compactThinking(pi: ExtensionAPI) {
 	// 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);
+			const lastMessage = (latestComponent as unknown as { lastMessage?: AssistantMessage })
+				?.lastMessage;
+			resumeAgentThinking(lastMessage);
 		} else {
 			finishThinking();
 		}
@@ -656,24 +689,33 @@ function compactThinking(pi: ExtensionAPI) {
 
 		// An empty widget gives the animation loop access to requestRender without
 		// enabling terminal mouse reporting or intercepting native scrollback input.
+		// setWidget 的 factory 同步执行，此刻补丁已安装。
 		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 在 reload/resume 时先于 session_start 用原始原型重建聊天组件
+		// （rebuildChatFromMessages / renderCurrentSessionState）。由共享的
+		// refreshMountedTranscript 扫描挂载树重绘这些组件，恢复 compact 渲染、
+		// 持久化时长与工具调用显示。
+		refreshMountedTranscript(activeTui);
+		activeTui?.requestRender(true);
 	});
 
 	pi.on("session_tree", (_event, ctx) => {
 		restoreDurationEntries(ctx.sessionManager.getBranch(), completedDurations);
-		refreshRenderedComponents();
+		refreshMountedTranscript(activeTui);
+		activeTui?.requestRender(true);
 	});
 
 	pi.on("session_shutdown", (_event, ctx) => {
 		finishThinking();
+		activeThinkingQuery = undefined;
+		activeThinkingStateQuery = undefined;
+		activeThinkingAnimationFrameQuery = undefined;
+		activeCompactSummarySetter = undefined;
+		compactSummaryActive = false;
 		if (animationTimer) clearInterval(animationTimer);
 		animationTimer = undefined;
 		activeTui = undefined;
@@ -681,12 +723,15 @@ function compactThinking(pi: ExtensionAPI) {
 		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;
+			if (prototype.updateContent === installedUpdateContent) {
+				const wrappedOriginal = (originalUpdateContent as any)[PROTOTYPE_ORIGINAL_KEY];
+				prototype.updateContent =
+					typeof wrappedOriginal === "function" ? wrappedOriginal : originalUpdateContent;
+			}
 			patchInstalled = false;
 		}
 	});
@@ -795,5 +840,17 @@ export function installCompactThinking(
 			Object.assign(initialConfig, next);
 			Object.assign(config, next);
 		},
+		getMessageThinkingDurationMs(messageTimestamp) {
+			return activeThinkingQuery?.(messageTimestamp);
+		},
+		isMessageThinkingActive(messageTimestamp) {
+			return activeThinkingStateQuery?.(messageTimestamp) ?? false;
+		},
+		getThinkingAnimationFrame() {
+			return activeThinkingAnimationFrameQuery?.() ?? 0;
+		},
+		setCompactSummaryActive(active) {
+			activeCompactSummarySetter?.(active);
+		},
 	};
 }

package/extensions/feature/context.ts

@@ -639,7 +639,7 @@ export default function contextUsageExtension(pi: ExtensionAPI) {
 				);
 
 				if (!action) break;
-				const preview = previewByKey.get(action);
+				const preview = previewByKey.get(action as PreviewKey);
 				if (!preview) continue;
 
 				await showTextPreview(ctx, preview.title, preview.content);

package/extensions/feature/markdown-enhance.ts

@@ -129,6 +129,18 @@ function linkifyUrls(markdown: string): string {
 	return out.join("\n");
 }
 
+// ============================================================================
+// 圈数字 → 半角括号
+// ============================================================================
+
+// Nerd Font 补丁字形（U+2460-U+2473）ink 超界，DirectWrite 下渲染会压住相邻字符；
+// 转成 ASCII "(n)" 后任何字体下宽度一致。U+2460-U+2473 连续，差值即序号。
+const CIRCLED_RE = /[①-⑳]/g;
+
+function deCircled(markdown: string): string {
+	return markdown.replace(CIRCLED_RE, (ch) => `(${ch.codePointAt(0)! - 0x2460 + 1})`);
+}
+
 // ============================================================================
 // 注册
 // ============================================================================
@@ -140,6 +152,8 @@ export default function (pi: ExtensionAPI): void {
 		const { messageType, isStreaming = false } = context ?? {};
 		// 与官方推荐一致：thinking 块与流式中间态不转换
 		if (messageType === "assistant-thinking" || isStreaming) return markdown;
+		// 0. 圈数字转半角括号（Nerd Font 补丁字形缺陷规避）
+		markdown = deCircled(markdown);
 		// 1. Mermaid 方言渲染
 		markdown = renderDiagrams(markdown, context);
 		// 2. GitHub 风格提示框

package/extensions/feature/session-reference-core.ts

@@ -2,7 +2,7 @@ export const SESSION_REFERENCE_CUSTOM_TYPE = "session-reference";
 export const SESSION_REFERENCE_PREFIX = "@session:";
 
 const SESSION_REFERENCE_PATTERN =
-	/(?:^|\s)@session:([A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?)(?![A-Za-z0-9._-])/g;
+	/(?:^|\s)@session:(?:\[([^\]]+)\]|([A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?))(?![\w.\]-])/g;
 const CONTROL_CHARACTERS = /[\u0000-\u001f\u007f]/g;
 
 export interface ReferenceSessionInfo {
@@ -31,12 +31,13 @@ export const DEFAULT_REFERENCE_LIMITS: ReferenceLimits = {
 	maxTotalBytes: 48_000,
 };
 
+/** 提取 @session:[name]（组 1）或旧格式 @session:id（组 2），返回 name 或 id。 */
 export function extractSessionReferenceIds(text: string): string[] {
 	const ids: string[] = [];
 	const seen = new Set<string>();
 
 	for (const match of text.matchAll(SESSION_REFERENCE_PATTERN)) {
-		const id = match[1];
+		const id = (match[1] ?? match[2])?.trim();
 		if (id && !seen.has(id)) {
 			seen.add(id);
 			ids.push(id);

package/extensions/feature/session-reference.ts

@@ -154,39 +154,47 @@ function formatDate(date: Date): string {
 
 /** Stable across keystrokes while getReferences returns the same reference objects. */
 const sessionSearchTextCache = new WeakMap<SessionReference, string>();
-const sessionItemCache = new WeakMap<SessionReference, { cwd: string; item: AutocompleteItem }>();
+const sessionItemCache = new WeakMap<
+	SessionReference,
+	{ cwd: string; named?: AutocompleteItem; stable?: AutocompleteItem }
+>();
 
 function sessionSearchText(reference: SessionReference): string {
 	const cached = sessionSearchTextCache.get(reference);
 	if (cached !== undefined) return cached;
-	const text = [
-		reference.info.name,
-		reference.info.firstMessage,
-		reference.info.cwd,
-		reference.info.id,
-		...reference.referenceIds,
-	]
-		.filter(Boolean)
-		.join(" ");
+	// 会话只按显式 session name 匹配，避免 firstMessage、路径或 ID 产生噪声。
+	const text = reference.info.name?.trim() ?? "";
 	sessionSearchTextCache.set(reference, text);
 	return text;
 }
 
-function sessionItem(reference: SessionReference, currentCwd: string): AutocompleteItem {
-	const cached = sessionItemCache.get(reference);
-	if (cached && cached.cwd === currentCwd) return cached.item;
+function sessionItem(
+	reference: SessionReference,
+	currentCwd: string,
+	useStableId: boolean,
+): AutocompleteItem {
+	let cached = sessionItemCache.get(reference);
+	const variant = useStableId ? "stable" : "named";
+	if (cached?.cwd === currentCwd && cached[variant]) return cached[variant];
 
 	const session = reference.info;
 	const workspace = samePath(session.cwd, currentCwd)
 		? "current workspace"
 		: session.cwd || "unknown workspace";
 	const label = reference.kind === "subagent" ? "[SubAgent]" : "[Session]";
+	// 唯一名称保持短格式；同名或无名称时使用稳定 ID，避免引用歧义。
+	const sessionName = session.name?.trim();
+	const referenceId = useStableId
+		? reference.referenceIds[0]
+		: (sessionName ?? reference.referenceIds[0]);
 	const item: AutocompleteItem = {
-		value: `${SESSION_REFERENCE_PREFIX}${reference.referenceIds[0]}`,
+		value: `${SESSION_REFERENCE_PREFIX}[${referenceId}]`,
 		label: `${label} ${sessionTitle(session)}`,
 		description: `${workspace} · ${session.messageCount} messages · ${formatDate(session.modified)}`,
 	};
-	sessionItemCache.set(reference, { cwd: currentCwd, item });
+	if (cached?.cwd !== currentCwd) cached = { cwd: currentCwd };
+	cached[variant] = item;
+	sessionItemCache.set(reference, cached);
 	return item;
 }
 
@@ -222,14 +230,24 @@ function filterSessions(
 	if (query.startsWith("session:")) return [];
 
 	const ordered = orderSessionReferences(references, currentCwd);
+	const nameCounts = new Map<string, number>();
+	for (const reference of ordered) {
+		const name = reference.info.name?.trim();
+		if (name) nameCounts.set(name, (nameCounts.get(name) ?? 0) + 1);
+	}
 	const trimmed = query.trim();
-	// Empty query: top-N already sorted — no fuzzy scan over the full list.
+	// 模糊匹配只接受有 session name 的会话；subagent 按 agent name 匹配。
+	const searchable = ordered.filter(
+		(reference) => reference.kind === "subagent" || Boolean(reference.info.name?.trim()),
+	);
+	// Empty query: top-N already sorted — no fuzzy scan over the full list。
 	const matches = trimmed
-		? fuzzyFilter(ordered, trimmed, sessionSearchText)
+		? fuzzyFilter(searchable, trimmed, sessionSearchText)
 		: ordered.slice(0, MAX_SESSION_SUGGESTIONS);
-	return matches
-		.slice(0, MAX_SESSION_SUGGESTIONS)
-		.map((reference) => sessionItem(reference, currentCwd));
+	return matches.slice(0, MAX_SESSION_SUGGESTIONS).map((reference) => {
+		const name = reference.info.name?.trim();
+		return sessionItem(reference, currentCwd, Boolean(name && (nameCounts.get(name) ?? 0) > 1));
+	});
 }
 
 function isPathLikeQuery(query: string): boolean {
@@ -470,12 +488,22 @@ export default function sessionReferenceExtension(pi: ExtensionAPI): void {
 				),
 			));
 		const referencesById = new Map<string, SessionReference>();
+		const referencesByName = new Map<string, SessionReference>();
+		const ambiguousNames = new Set<string>();
 		for (const reference of references) {
 			for (const id of reference.referenceIds) referencesById.set(id, reference);
+			const name = reference.info.name?.trim();
+			if (!name || ambiguousNames.has(name)) continue;
+			if (referencesByName.has(name)) {
+				referencesByName.delete(name);
+				ambiguousNames.add(name);
+			} else {
+				referencesByName.set(name, reference);
+			}
 		}
 		const seenReferences = new Set<SessionReference>();
 		const matchingReferences = referenceIds
-			.map((id) => referencesById.get(id))
+			.map((id) => referencesById.get(id) ?? referencesByName.get(id))
 			.filter((reference): reference is SessionReference => {
 				if (!reference || reference.info.id === currentSessionId || seenReferences.has(reference))
 					return false;

package/extensions/index.ts

@@ -22,6 +22,18 @@ export default function (pi: ExtensionAPI): void {
 		updateConfig(next) {
 			compactThinking?.updateConfig(next);
 		},
+		getMessageThinkingDurationMs(messageTimestamp) {
+			return compactThinking?.getMessageThinkingDurationMs?.(messageTimestamp);
+		},
+		isMessageThinkingActive(messageTimestamp) {
+			return compactThinking?.isMessageThinkingActive?.(messageTimestamp) ?? false;
+		},
+		getThinkingAnimationFrame() {
+			return compactThinking?.getThinkingAnimationFrame?.() ?? 0;
+		},
+		setCompactSummaryActive(active) {
+			compactThinking?.setCompactSummaryActive?.(active);
+		},
 	};
 	claudeCodeStyle(pi, undefined, compactThinkingBridge);
 	compactThinking = installCompactThinking(pi, getCompactThinkingConfig());