pi-cc-extensions 0.8.13 → 0.8.15

package/extensions/compact-style.ts

@@ -192,7 +192,8 @@ function shortenPath(path: unknown): string {
 }
 
 function oneLine(value: unknown): string {
-	return sanitizeToolResultText(String(value ?? ""))
+	// Preview paths only need a short prefix; skip scanning multi-MB tool outputs.
+	return sanitizeToolResultText(String(value ?? ""), 4_096)
 		.replace(/\s+/g, " ")
 		.trim();
 }
@@ -298,7 +299,8 @@ export function resultPreview(result: any, isPartial = false): string {
 		? result.content.find((c: any) => c?.type === "text" && typeof c.text === "string")?.text
 		: undefined;
 	if (!text) return isPartial ? "running" : "";
-	const lines = sanitizeToolResultText(text)
+	// Only the first non-empty line / line count is used; bound the scan window.
+	const lines = sanitizeToolResultText(text, 8_192)
 		.trim()
 		.split("\n")
 		.filter((line) => line.trim().length > 0);

package/extensions/context.ts

@@ -213,19 +213,53 @@ export function formatTokens(tokens: number): string {
 	return `${Math.round(tokens / 1_000)}k`;
 }
 
-function collectParts(ctx: ExtensionCommandContext): ContextPart[] {
-	const options = ctx.getSystemPromptOptions();
+type SystemPromptOptions = {
+	contextFiles?: Array<{ path: string; content: string }>;
+	skills?: Array<{
+		name: string;
+		description?: string;
+		filePath?: string;
+		disableModelInvocation?: boolean;
+	}>;
+	selectedTools?: string[];
+	toolSnippets?: Record<string, string>;
+	promptGuidelines?: string[];
+};
+
+type ContextBreakdown = {
+	parts: ContextPart[];
+	options: SystemPromptOptions;
+	systemPrompt: string;
+};
+
+/**
+ * Single pass over prompt options + session entries. Returns options/systemPrompt
+ * so the /context UI does not re-fetch or re-stringify the same sources.
+ */
+function collectContextBreakdown(ctx: ExtensionCommandContext): ContextBreakdown {
+	const options = (ctx.getSystemPromptOptions?.() ?? {}) as SystemPromptOptions;
+	const systemPrompt = typeof ctx.getSystemPrompt === "function" ? ctx.getSystemPrompt() : "";
+
 	const contextFileTokens = (options.contextFiles ?? []).reduce(
 		(sum, file) => sum + tokenEstimate(file.content),
 		0,
 	);
-	const skillTokens = (options.skills ?? []).reduce((sum, skill) => sum + tokenEstimate(skill), 0);
+	// Prefer field-level estimates over JSON.stringify(whole skill).
+	const skillTokens = (options.skills ?? []).reduce((sum, skill) => {
+		if (!skill || typeof skill !== "object") return sum + tokenEstimate(skill);
+		return (
+			sum +
+			tokenEstimate(skill.name) +
+			tokenEstimate(skill.description) +
+			tokenEstimate(skill.filePath)
+		);
+	}, 0);
 	const tools = options.selectedTools ?? [];
-	const toolTokens =
-		tools.reduce(
-			(sum, name) => sum + tokenEstimate(name) + tokenEstimate(options.toolSnippets?.[name]),
-			0,
-		) + tokenEstimate(options.promptGuidelines);
+	const snippets = options.toolSnippets;
+	let toolTokens = tokenEstimate(options.promptGuidelines);
+	for (const name of tools) {
+		toolTokens += tokenEstimate(name) + tokenEstimate(snippets?.[name]);
+	}
 
 	let user = 0;
 	let assistant = 0;
@@ -242,7 +276,7 @@ function collectParts(ctx: ExtensionCommandContext): ContextPart[] {
 		}
 	}
 
-	const systemTotal = tokenEstimate(ctx.getSystemPrompt());
+	const systemTotal = tokenEstimate(systemPrompt);
 	const baseSystem = Math.max(0, systemTotal - contextFileTokens - skillTokens - toolTokens);
 	const parts: ContextPart[] = [
 		{ label: "System prompt", tokens: baseSystem, color: "accent" },
@@ -254,7 +288,11 @@ function collectParts(ctx: ExtensionCommandContext): ContextPart[] {
 		{ label: "Tool results", tokens: toolResults, color: "dim" },
 		{ label: "Compaction summaries", tokens: summaries, color: "success" },
 	];
-	return parts.filter((part) => part.tokens > 0);
+	return {
+		parts: parts.filter((part) => part.tokens > 0),
+		options,
+		systemPrompt,
+	};
 }
 
 export default function contextUsageExtension(pi: ExtensionAPI) {
@@ -263,8 +301,9 @@ export default function contextUsageExtension(pi: ExtensionAPI) {
 		handler: async (_args, ctx) => {
 			const usage = ctx.getContextUsage();
 			const contextWindow = usage?.contextWindow ?? ctx.model?.contextWindow ?? 0;
-			const used = usage?.tokens ?? collectParts(ctx).reduce((sum, part) => sum + part.tokens, 0);
-			const parts = scaleParts(collectParts(ctx), used);
+			const breakdown = collectContextBreakdown(ctx);
+			const used = usage?.tokens ?? breakdown.parts.reduce((sum, part) => sum + part.tokens, 0);
+			const parts = scaleParts(breakdown.parts, used);
 			const free = Math.max(0, contextWindow - used);
 			const allParts = [...parts, { label: "Free space", tokens: free, color: "dim" as const }];
 
@@ -274,7 +313,7 @@ export default function contextUsageExtension(pi: ExtensionAPI) {
 				return;
 			}
 
-			const options = ctx.getSystemPromptOptions();
+			const options = breakdown.options;
 			const toolByName = new Map<string, ToolPreviewInfo>(
 				(pi.getAllTools() as ToolPreviewInfo[]).map((tool) => [tool.name, tool] as const),
 			);
@@ -313,7 +352,7 @@ export default function contextUsageExtension(pi: ExtensionAPI) {
 					key: "systemPrompt",
 					label: "System prompt",
 					title: "System Prompt",
-					content: ctx.getSystemPrompt(),
+					content: breakdown.systemPrompt,
 				},
 				{
 					key: "tools",

package/extensions/session-reference.ts

@@ -66,6 +66,20 @@ type SubagentManager = {
 
 // Local subagent record tracking (pi-subagents does not expose a global manager).
 const liveSubagentRecords = new Map<string, SubagentLiveRecord>();
+/** Cap retained completed/live records so long-lived pi processes cannot grow unbounded. */
+const MAX_LIVE_SUBAGENT_RECORDS = 200;
+
+function pruneLiveSubagentRecords(): void {
+	while (liveSubagentRecords.size > MAX_LIVE_SUBAGENT_RECORDS) {
+		const oldest = liveSubagentRecords.keys().next().value;
+		if (oldest === undefined) break;
+		liveSubagentRecords.delete(oldest);
+	}
+}
+
+function clearLiveSubagentRecords(): void {
+	liveSubagentRecords.clear();
+}
 
 function trackSubagentFromEvent(data: unknown): void {
 	if (!data || typeof data !== "object") return;
@@ -87,6 +101,9 @@ function trackSubagentFromEvent(data: unknown): void {
 				typeof event.endedAt === "number" ? event.endedAt : event.lastUpdate
 			) as number;
 		}
+		// Refresh insertion order so completed-but-still-referenced runs stay recent.
+		liveSubagentRecords.delete(runId);
+		liveSubagentRecords.set(runId, existing);
 		return;
 	}
 	// Started event — create new record
@@ -100,6 +117,7 @@ function trackSubagentFromEvent(data: unknown): void {
 		cwd,
 		startedAt,
 	});
+	pruneLiveSubagentRecords();
 }
 
 function getSubagentManager(): SubagentManager | undefined {
@@ -134,8 +152,14 @@ function formatDate(date: Date): string {
 	}).format(date);
 }
 
+/** 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 }>();
+
 function sessionSearchText(reference: SessionReference): string {
-	return [
+	const cached = sessionSearchTextCache.get(reference);
+	if (cached !== undefined) return cached;
+	const text = [
 		reference.info.name,
 		reference.info.firstMessage,
 		reference.info.cwd,
@@ -144,34 +168,65 @@ function sessionSearchText(reference: SessionReference): string {
 	]
 		.filter(Boolean)
 		.join(" ");
+	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;
+
 	const session = reference.info;
 	const workspace = samePath(session.cwd, currentCwd)
 		? "current workspace"
 		: session.cwd || "unknown workspace";
 	const label = reference.kind === "subagent" ? "[SubAgent]" : "[Session]";
-	return {
+	const item: AutocompleteItem = {
 		value: `${SESSION_REFERENCE_PREFIX}${reference.referenceIds[0]}`,
 		label: `${label} ${sessionTitle(session)}`,
 		description: `${workspace} · ${session.messageCount} messages · ${formatDate(session.modified)}`,
 	};
+	sessionItemCache.set(reference, { cwd: currentCwd, item });
+	return item;
 }
 
-function filterSessions(
+/** Sort cache: same array + cwd reuses order (getReferences returns a stable ordered array). */
+const orderedReferencesCache = new WeakMap<
+	SessionReference[],
+	{ cwd: string; ordered: SessionReference[] }
+>();
+
+function orderSessionReferences(
 	references: SessionReference[],
-	query: string,
 	currentCwd: string,
-): AutocompleteItem[] {
-	if (query.startsWith("session:")) return [];
+): SessionReference[] {
+	const cached = orderedReferencesCache.get(references);
+	if (cached && cached.cwd === currentCwd) return cached.ordered;
 
 	const ordered = [...references].sort((left, right) => {
 		const leftLocal = samePath(left.info.cwd, currentCwd) ? 1 : 0;
 		const rightLocal = samePath(right.info.cwd, currentCwd) ? 1 : 0;
 		return rightLocal - leftLocal || right.info.modified.getTime() - left.info.modified.getTime();
 	});
-	const matches = query.trim() ? fuzzyFilter(ordered, query, sessionSearchText) : ordered;
+	orderedReferencesCache.set(references, { cwd: currentCwd, ordered });
+	// Point the ordered array at itself so subsequent keystrokes skip re-sorting.
+	orderedReferencesCache.set(ordered, { cwd: currentCwd, ordered });
+	return ordered;
+}
+
+function filterSessions(
+	references: SessionReference[],
+	query: string,
+	currentCwd: string,
+): AutocompleteItem[] {
+	if (query.startsWith("session:")) return [];
+
+	const ordered = orderSessionReferences(references, currentCwd);
+	const trimmed = query.trim();
+	// Empty query: top-N already sorted — no fuzzy scan over the full list.
+	const matches = trimmed
+		? fuzzyFilter(ordered, trimmed, sessionSearchText)
+		: ordered.slice(0, MAX_SESSION_SUGGESTIONS);
 	return matches
 		.slice(0, MAX_SESSION_SUGGESTIONS)
 		.map((reference) => sessionItem(reference, currentCwd));
@@ -341,6 +396,7 @@ export default function sessionReferenceExtension(pi: ExtensionAPI): void {
 	pi.on("session_start", (_event, ctx) => {
 		const generation = ++sessionGeneration;
 		subagentIds.clear();
+		clearLiveSubagentRecords();
 		let loadErrorShown = false;
 		const currentSessionId = ctx.sessionManager.getSessionId();
 		const currentSessionFile = ctx.sessionManager.getSessionFile();
@@ -365,8 +421,27 @@ export default function sessionReferenceExtension(pi: ExtensionAPI): void {
 			return sessionsPromise;
 		};
 
-		const getReferences = async (): Promise<SessionReference[]> =>
-			mergeReferences(await getSessions(), liveSubagentReferences(subagentIds, currentSessionId));
+		// Pre-sort once per (sessions list, subagent id set) so @ keystrokes only fuzzy-filter.
+		let referencesCache:
+			| { sessions: SessionInfo[]; subagentKey: string; ordered: SessionReference[] }
+			| undefined;
+		const getReferences = async (): Promise<SessionReference[]> => {
+			const sessions = await getSessions();
+			const subagentKey = [...subagentIds].join("\0");
+			if (
+				referencesCache &&
+				referencesCache.sessions === sessions &&
+				referencesCache.subagentKey === subagentKey
+			) {
+				return referencesCache.ordered;
+			}
+			const ordered = orderSessionReferences(
+				mergeReferences(sessions, liveSubagentReferences(subagentIds, currentSessionId)),
+				ctx.cwd,
+			);
+			referencesCache = { sessions, subagentKey, ordered };
+			return ordered;
+		};
 
 		getAvailableReferences = getReferences;
 		if (ctx.mode === "tui") {
@@ -463,6 +538,7 @@ export default function sessionReferenceExtension(pi: ExtensionAPI): void {
 
 	pi.on("session_before_switch", () => {
 		subagentIds.clear();
+		clearLiveSubagentRecords();
 		getAvailableReferences = undefined;
 	});
 
@@ -470,6 +546,7 @@ export default function sessionReferenceExtension(pi: ExtensionAPI): void {
 		sessionGeneration++;
 		for (const unsubscribe of unsubscribeSubagentEvents) unsubscribe();
 		subagentIds.clear();
+		clearLiveSubagentRecords();
 		getAvailableReferences = undefined;
 	});
 }