@dyyz1993/pi-coding-agent 0.74.47 → 0.74.48

package/dist/extensions/compaction-manager/index.ts

@@ -27,6 +27,8 @@ function loadConfig(): CompactionManagerConfig {
 	return DEFAULT_CONFIG;
 }
 
+let compactMetrics = { foldCount: 0, memoryCompactCount: 0, forceCompactCount: 0, rateLimitHits: 0, serverErrors: 0 };
+
 export default function (pi: ExtensionAPI) {
 	const config = loadConfig();
 
@@ -70,11 +72,17 @@ export default function (pi: ExtensionAPI) {
 				pi.foldEntry(entry.id, summary, tokens);
 			}
 
+			compactMetrics.foldCount++;
 			ctx.ui.notify(`Context fold: folded ${foldable.length} old message(s)`, "info");
+			pi.appendEntry("compaction_fold", {
+				count: foldable.length,
+				totalFolds: compactMetrics.foldCount,
+				timestamp: Date.now(),
+			});
 		});
 	}
 
-	if (config.sessionMemory.enabled) {
+		if (config.sessionMemory.enabled) {
 		pi.on("session_before_compact", async (event, ctx) => {
 			const { preparation, signal } = event;
 
@@ -84,10 +92,16 @@ export default function (pi: ExtensionAPI) {
 			const result = buildMemorySummary(memoryFiles, preparation, config.sessionMemory.minContentLength);
 			if (!result) return;
 
+			compactMetrics.memoryCompactCount++;
 			ctx.ui.notify(
 				`Session Memory Compact: using ${memoryFiles.size} memory files instead of LLM summary`,
 				"info",
 			);
+			pi.appendEntry("compaction_session_memory", {
+				memoryFiles: memoryFiles.size,
+				totalMemory: compactMetrics.memoryCompactCount,
+				timestamp: Date.now(),
+			});
 
 			return { compaction: result };
 		});
@@ -98,9 +112,28 @@ export default function (pi: ExtensionAPI) {
 
 		pi.on("after_provider_response", (event, ctx) => {
 			if (event.status === 429) {
+				compactMetrics.rateLimitHits++;
 				ctx.ui.notify("Rate limited — API is throttling requests", "warning");
+				pi.sendUserMessage(
+					"[System: API Rate Limited] Requests are being throttled. The session will retry automatically. Consider reducing tool call frequency or waiting.",
+					{ deliverAs: "followUp" },
+				);
+				pi.appendEntry("compaction_rate_limit", {
+					total: compactMetrics.rateLimitHits,
+					timestamp: Date.now(),
+				});
 			} else if (event.status >= 500) {
+				compactMetrics.serverErrors++;
 				ctx.ui.notify(`API server error (${event.status}) — will retry automatically`, "warning");
+				pi.sendUserMessage(
+					`[System: API Error] Server error (${event.status}) encountered. The session will retry automatically.`,
+					{ deliverAs: "followUp" },
+				);
+				pi.appendEntry("compaction_server_error", {
+					status: event.status,
+					total: compactMetrics.serverErrors,
+					timestamp: Date.now(),
+				});
 			}
 		});
 
@@ -111,18 +144,35 @@ export default function (pi: ExtensionAPI) {
 			const { tokens, contextWindow, percent } = usage;
 
 			if (shouldForceCompact(tokens, contextWindow, config.reactive.forceCompactPercent) && !warnedThisTurn) {
-				ctx.ui.notify(
-					`Context critical: ${percent!.toFixed(0)}% (${tokens!.toLocaleString()} / ${contextWindow.toLocaleString()} tokens). Consider /compact-force.`,
-					"warning",
+				const msg = `Context critical: ${percent!.toFixed(0)}% (${tokens!.toLocaleString()} / ${contextWindow.toLocaleString()} tokens). Automatic compaction imminent.`;
+				ctx.ui.notify(msg, "warning");
+				pi.sendUserMessage(
+					`[System: Context Warning — Action Required]\n`
+						+ `Context window is at ${percent!.toFixed(0)}% — critical. Automatic compaction will occur soon.\n\n`
+						+ `Compaction is lossy: after compression, the conversation context may lose detail, making current results unreliable.\n\n`
+						+ `Recommended actions:\n`
+						+ `1. Return your current findings and conclusions to the parent session now (before compaction).\n`
+						+ `2. If the task is complex, break it down: return your direction/framework to the parent,\n`
+						+ `   so the parent can re-dispatch more targeted sub-tasks with fresh context.\n`
+						+ `3. Use available communication tools to send results back.`,
+					{ deliverAs: "followUp" },
 				);
 				warnedThisTurn = true;
 				return;
 			}
 
 			if (shouldWarn(tokens, contextWindow, config.reactive.warnPercent) && !warnedThisTurn) {
-				ctx.ui.notify(
-					`Context high: ${percent!.toFixed(0)}% (${tokens!.toLocaleString()} / ${contextWindow.toLocaleString()} tokens)`,
-					"info",
+				const msg = `Context high: ${percent!.toFixed(0)}% (${tokens!.toLocaleString()} / ${contextWindow.toLocaleString()} tokens)`;
+				ctx.ui.notify(msg, "info");
+				pi.sendUserMessage(
+					`[System: Context Warning — Proactive]\n`
+						+ `Context window at ${percent!.toFixed(0)}% — approaching the compaction threshold.\n\n`
+						+ `Before automatic compaction reduces context fidelity:\n`
+						+ `- Consider completing the current task and returning results now.\n`
+						+ `- If the task is still large, return your current findings and direction,\n`
+						+ `  so the parent can re-dispatch with a more focused scope.\n`
+						+ `- Lossy compaction will make current details unreliable after compression.`,
+					{ deliverAs: "followUp" },
 				);
 				warnedThisTurn = true;
 			}
@@ -139,10 +189,21 @@ export default function (pi: ExtensionAPI) {
 				ctx.compact({
 					customInstructions: instructions,
 					onComplete: (result) => {
+						compactMetrics.forceCompactCount++;
 						ctx.ui.notify(`Compaction done: ${result.tokensBefore.toLocaleString()} tokens compressed`, "info");
+						pi.appendEntry("compaction_force", {
+							tokensBefore: result.tokensBefore,
+							total: compactMetrics.forceCompactCount,
+							timestamp: Date.now(),
+						});
 					},
 					onError: (error) => {
 						ctx.ui.notify(`Compaction failed: ${error.message}`, "error");
+						pi.appendEntry("compaction_failed", {
+							error: error.message,
+							total: compactMetrics.forceCompactCount,
+							timestamp: Date.now(),
+						});
 					},
 				});
 			},

package/dist/extensions/coordinator/index.ts

@@ -161,12 +161,22 @@ export default function coordinatorExtension(pi: ExtensionAPI) {
       const result = await serverProxy.delegate(params.task, projectPath);
 
       if (!result.sessionId) {
+        console.debug("[coordinator] delegate failed: no sessionId returned");
+        pi.appendEntry("coordinator_delegate_failed", { task: params.task, projectPath });
         return {
           content: [{ type: "text" as const, text: `Failed to delegate task: no sessionId returned.` }],
           details: { error: "no sessionId" },
         };
       }
 
+      pi.appendEntry("coordinator_delegate", {
+        sessionId: result.sessionId,
+        status: result.status,
+        task: params.task,
+        title: params.title,
+        projectPath,
+        dispatchedBy: sid,
+      });
       return {
         content: [{ type: "text" as const, text: `Delegated task to session ${result.sessionId} (status: ${result.status}, cwd: ${projectPath}). Use session_delegate_send to communicate.` }],
         details: { ...result, dispatchedBy: sid, projectPath },
@@ -190,12 +200,14 @@ export default function coordinatorExtension(pi: ExtensionAPI) {
       const result = await serverProxy.delegate_send(sid, params.targetSessionId, params.message);
 
       if (!result.delivered) {
+        pi.appendEntry("coordinator_send_failed", { fromSessionId: sid, toSessionId: params.targetSessionId });
         return {
           content: [{ type: "text" as const, text: `Could not deliver message to ${params.targetSessionId}: session not found (the session file may have been deleted from disk)` }],
           details: { delivered: false, targetSessionId: params.targetSessionId },
         };
       }
 
+      pi.appendEntry("coordinator_send", { fromSessionId: sid, toSessionId: params.targetSessionId, status: result.targetStatus });
       return {
         content: [{ type: "text" as const, text: `Message delivered to ${params.targetSessionId} (status: ${result.targetStatus})` }],
         details: result,
@@ -253,6 +265,15 @@ export default function coordinatorExtension(pi: ExtensionAPI) {
       const sid = currentSessionId || ctx.sessionManager.getSessionId();
       const projectPath = params.projectPath || ctx.cwd;
       const result = await serverProxy.delegate_fork(params.sessionId, params.task, params.title, projectPath);
+      pi.appendEntry("coordinator_fork", {
+        sessionId: result.sessionId,
+        forkedFrom: params.sessionId,
+        status: result.status,
+        task: params.task,
+        title: params.title,
+        projectPath,
+        dispatchedBy: sid,
+      });
       return {
         content: [{ type: "text" as const, text: `Forked session ${params.sessionId} → ${result.sessionId} (status: ${result.status}, cwd: ${projectPath}). Task: ${params.task}` }],
         details: { ...result, forkedFrom: params.sessionId, dispatchedBy: sid, projectPath },
@@ -260,6 +281,21 @@ export default function coordinatorExtension(pi: ExtensionAPI) {
     },
   });
 
+  pi.registerTool({
+    name: "session_delegate_stop",
+    label: "Session Delegate Stop",
+    description: "Stop a delegated task session.",
+    parameters: DelegateStopParams,
+    async execute(toolCallId, params, _signal, _onUpdate, _ctx) {
+      const ok = await serverProxy.delegate_stop(params.sessionId);
+      pi.appendEntry("coordinator_stop", { sessionId: params.sessionId, ok });
+      return {
+        content: [{ type: "text" as const, text: ok ? `Session ${params.sessionId} stopped.` : `Session ${params.sessionId} not found or already stopped.` }],
+        details: { ok },
+      };
+    },
+  });
+
   pi.registerTool({
     name: "session_delegate_remove",
     label: "Session Delegate Remove",
@@ -271,6 +307,7 @@ export default function coordinatorExtension(pi: ExtensionAPI) {
     parameters: DelegateStatusParams,
     async execute(toolCallId, params, _signal, _onUpdate, _ctx) {
       const ok = await serverProxy.delegate_remove(params.sessionId);
+      pi.appendEntry("coordinator_remove", { sessionId: params.sessionId, ok });
       return {
         content: [{ type: "text" as const, text: ok ? `Task ${params.sessionId} removed.` : `Task ${params.sessionId} not found.` }],
         details: { ok },
@@ -288,6 +325,7 @@ export default function coordinatorExtension(pi: ExtensionAPI) {
     parameters: Type.Object({}),
     async execute(toolCallId, _params, _signal, _onUpdate, _ctx) {
       const removed = await serverProxy.delegate_clear_stopped();
+      pi.appendEntry("coordinator_clear_stopped", { removed });
       return {
         content: [{ type: "text" as const, text: `Cleared ${removed} stopped/completed task(s).` }],
         details: { removed },
@@ -307,6 +345,7 @@ export default function coordinatorExtension(pi: ExtensionAPI) {
       const isCompletion = lowerMsg.includes("[completed]") || lowerMsg.includes("[done]") || lowerMsg.includes("task completed");
       if (isCompletion) {
         store.update(d.fromSessionId, { status: "completed", completedAt: Date.now(), result: d.message });
+        pi.appendEntry("coordinator_task_completed", { sessionId: d.fromSessionId, task: task.title, result: d.message.slice(0, 200) });
       } else if (task.status !== "completed") {
         store.update(d.fromSessionId, { status: "streaming" });
       }

package/dist/extensions/hooks-engine/index.ts

@@ -193,6 +193,9 @@ export default function hooksEngine(pi: ExtensionAPI): void {
 
 			if (promptResults.length > 0) {
 				console.log("[hook] Prompts to inject:", promptResults);
+				for (const prompt of promptResults) {
+					pi.sendUserMessage(prompt, { deliverAs: "followUp" });
+				}
 			}
 
 			return undefined;

package/dist/extensions/lsp/lsp/client/smart-file-tracker.ts

@@ -0,0 +1,302 @@
+import { extname } from "node:path";
+
+export interface SmartFileTrackerOptions {
+	maxOpenFiles?: number;
+	now?: () => number;
+	priorityMap?: Record<string, number>;
+	excludedExtensions?: Set<string>;
+}
+
+export interface MemoryUsage {
+	heapUsed: number;
+	heapTotal: number;
+}
+
+export interface TrackerStatistics {
+	totalOpens: number;
+	totalEvictions: number;
+	evictionReasons: Array<"window_full" | "memory_pressure" | "excluded_type">;
+	accessCounts: Map<string, number>;
+	openFileCount: number;
+}
+
+interface TrackedFile {
+	filePath: string;
+	lastAccess: number;
+	modifiedTime: number;
+	accessCount: number;
+	priority: number;
+}
+
+// Default priority map for common file types (higher = more important)
+const DEFAULT_PRIORITY_MAP: Record<string, number> = {
+	// TypeScript/JavaScript (highest)
+	".ts": 100,
+	".tsx": 100,
+	".js": 90,
+	".jsx": 90,
+	".mjs": 90,
+	".cjs": 90,
+
+	// Framework files
+	".vue": 95,
+	".svelte": 95,
+
+	// Other languages
+	".py": 80,
+	".rs": 80,
+	".go": 80,
+	".java": 75,
+	".kt": 75,
+	".c": 70,
+	".cpp": 70,
+	".h": 70,
+	".hpp": 70,
+	".cs": 70,
+
+	// Config files
+	".json": 30,
+	".yaml": 30,
+	".yml": 30,
+	".toml": 30,
+
+	// Documentation
+	".md": 20,
+
+	// Text files
+	".txt": 10,
+};
+
+	// Default excluded file types (never tracked)
+const DEFAULT_EXCLUDED_EXTENSIONS: Set<string> = new Set([
+	".log",
+	".bak",
+	".tmp",
+	".temp",
+	".swp",
+	".cache",
+	".DS_Store",
+	".map",
+	".lock",
+	".pid",
+	// Special files without extension
+	".gitignore",
+	".gitattributes",
+	".gitmodules",
+	".editorconfig",
+	".eslintrc",
+	".prettierrc",
+]);
+
+// Memory thresholds (in bytes)
+const HIGH_MEMORY_THRESHOLD = 3_000_000_000; // 3GB
+const CRITICAL_MEMORY_THRESHOLD = 3_500_000_000; // 3.5GB
+const BASE_MAX_FILES = 30;
+const HIGH_MEMORY_MAX_FILES = 10;
+const CRITICAL_MEMORY_MAX_FILES = 5;
+
+export interface SmartFileTracker {
+	open(filePath: string, onClose: (file: string) => void, mtime?: number): void;
+	getOpenFiles(): string[];
+	closeAll(onClose: (file: string) => void): void;
+	updateMemoryUsage(usage: MemoryUsage): void;
+	getStatistics(): TrackerStatistics;
+}
+
+export function createSmartFileTracker(options: SmartFileTrackerOptions = {}): SmartFileTracker {
+	const baseMaxOpenFiles = options.maxOpenFiles ?? BASE_MAX_FILES;
+	const now = options.now ?? (() => Date.now());
+	const priorityMap = options.priorityMap ?? DEFAULT_PRIORITY_MAP;
+	const excludedExtensions = options.excludedExtensions ?? DEFAULT_EXCLUDED_EXTENSIONS;
+
+	const files = new Map<string, TrackedFile>();
+	const stats: TrackerStatistics = {
+		totalOpens: 0,
+		totalEvictions: 0,
+		evictionReasons: [],
+		accessCounts: new Map(),
+		openFileCount: 0,
+	};
+
+	let memoryUsage: MemoryUsage = {
+		heapUsed: 0,
+		heapTotal: 0,
+	};
+
+	// Calculate current max files based on memory pressure
+	function getCurrentMaxFiles(): number {
+		if (!memoryUsage.heapUsed || !memoryUsage.heapTotal) {
+			return baseMaxOpenFiles;
+		}
+
+		const memoryRatio = memoryUsage.heapUsed / memoryUsage.heapTotal;
+
+		if (memoryRatio > CRITICAL_MEMORY_THRESHOLD / memoryUsage.heapTotal) {
+			return Math.min(CRITICAL_MEMORY_MAX_FILES, baseMaxOpenFiles);
+		}
+
+		if (memoryRatio > HIGH_MEMORY_THRESHOLD / memoryUsage.heapTotal) {
+			return Math.min(HIGH_MEMORY_MAX_FILES, baseMaxOpenFiles);
+		}
+
+		return baseMaxOpenFiles;
+	}
+
+	// Get file priority based on extension
+	function getFilePriority(filePath: string): number {
+		const ext = extname(filePath).toLowerCase();
+		return priorityMap[ext] ?? 50; // Default priority for unknown types
+	}
+
+	// Check if file should be excluded
+	function isExcluded(filePath: string): boolean {
+		const ext = extname(filePath).toLowerCase();
+		if (excludedExtensions.has(ext)) {
+			return true;
+		}
+
+		// Check excluded file names (files without extension like .gitignore)
+		const basename = filePath.split("/").pop() ?? filePath;
+		if (excludedExtensions.has(basename)) {
+			return true;
+		}
+
+		return false;
+	}
+
+	// Sort files by priority (higher first), then by modified time (newer first), then by last access
+	function getSortedFiles(): TrackedFile[] {
+		return Array.from(files.values()).sort((a, b) => {
+			// Higher priority first
+			if (b.priority !== a.priority) {
+				return b.priority - a.priority;
+			}
+			// Newer modified time first
+			if (b.modifiedTime !== a.modifiedTime) {
+				return b.modifiedTime - a.modifiedTime;
+			}
+			// More recently accessed first
+			if (b.lastAccess !== a.lastAccess) {
+				return b.lastAccess - a.lastAccess;
+			}
+			// Higher access count first
+			return b.accessCount - a.accessCount;
+		});
+	}
+
+	// Evict lowest priority file(s) to fit new file
+	function evictIfNeeded(onClose: (file: string) => void): void {
+		const currentMax = getCurrentMaxFiles();
+		// Evict if we're at or over the limit (before adding new file)
+		while (files.size >= currentMax) {
+			const sorted = getSortedFiles();
+			const lowest = sorted[sorted.length - 1]; // Last element has lowest priority
+
+			if (!lowest) {
+				break;
+			}
+
+			files.delete(lowest.filePath);
+			onClose(lowest.filePath);
+
+			stats.totalEvictions++;
+			stats.evictionReasons.push("window_full");
+			stats.openFileCount = files.size;
+
+			// If memory is high, evict multiple files
+			const memoryRatio = memoryUsage.heapUsed / memoryUsage.heapTotal;
+			if (memoryRatio > HIGH_MEMORY_THRESHOLD / memoryUsage.heapTotal && files.size > currentMax / 2) {
+				continue; // Keep evicting
+			}
+
+			break;
+		}
+	}
+
+	// Evict files to fit within memory constraints
+	function evictForMemory(onClose?: (file: string) => void): void {
+		const currentMax = getCurrentMaxFiles();
+		while (files.size > currentMax) {
+			const sorted = getSortedFiles();
+			const lowest = sorted[sorted.length - 1];
+
+			if (!lowest) {
+				break;
+			}
+
+			files.delete(lowest.filePath);
+			if (onClose) {
+				onClose(lowest.filePath);
+			}
+
+			stats.totalEvictions++;
+			stats.evictionReasons.push("memory_pressure");
+			stats.openFileCount = files.size;
+		}
+	}
+
+	return {
+		open(filePath: string, onClose: (file: string) => void, mtime?: number): void {
+			// Check if file is excluded
+			if (isExcluded(filePath)) {
+				onClose(filePath);
+				stats.totalEvictions++;
+				stats.evictionReasons.push("excluded_type");
+				return;
+			}
+
+			stats.totalOpens++;
+
+			// Update access count
+			const currentCount = stats.accessCounts.get(filePath) ?? 0;
+			stats.accessCounts.set(filePath, currentCount + 1);
+
+			// If file already exists, update its metadata
+			if (files.has(filePath)) {
+				const entry = files.get(filePath)!;
+				entry.lastAccess = now();
+				entry.modifiedTime = mtime ?? entry.modifiedTime;
+				entry.accessCount++;
+				return;
+			}
+
+			// Evict files if needed (before adding new file)
+			evictIfNeeded(onClose);
+
+			// Add new file
+			const newFile: TrackedFile = {
+				filePath,
+				lastAccess: now(),
+				modifiedTime: mtime ?? now(),
+				accessCount: 1,
+				priority: getFilePriority(filePath),
+			};
+
+			files.set(filePath, newFile);
+			stats.openFileCount = files.size;
+		},
+
+		getOpenFiles(): string[] {
+			const sorted = getSortedFiles();
+			return sorted.map((f) => f.filePath);
+		},
+
+		closeAll(onClose: (file: string) => void): void {
+			for (const filePath of files.keys()) {
+				onClose(filePath);
+			}
+			files.clear();
+			stats.openFileCount = 0;
+		},
+
+		updateMemoryUsage(usage: MemoryUsage): void {
+			memoryUsage = usage;
+			// Evict files if memory pressure increased window size
+			evictForMemory();
+		},
+
+		getStatistics(): TrackerStatistics {
+			return { ...stats, accessCounts: new Map(stats.accessCounts) };
+		},
+	};
+}