pi-crew 0.2.16 → 0.2.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-crew",
-  "version": "0.2.16",
+  "version": "0.2.17",
   "description": "Pi extension for coordinated AI teams, workflows, worktrees, and async task orchestration",
   "author": "baphuongna",
   "license": "MIT",

package/src/extension/registration/compaction-guard.ts

@@ -67,6 +67,7 @@ function formatCrewArtifactIndex(entries: CrewArtifactIndexEntry[]): string {
 }
 
 export function registerCompactionGuard(pi: ExtensionAPI, options: RegisterCompactionGuardOptions): void {
+	let pendingCompactReason: string | null = null;
 	let compactionInProgress = false;
 
 	const startCompact = (ctx: ExtensionContext, reason: string): void => {
@@ -93,22 +94,39 @@ export function registerCompactionGuard(pi: ExtensionAPI, options: RegisterCompa
 		});
 	};
 
-	// Phase 1.2: Allow compaction during foreground runs.
-	// Previously this deferred compaction, but that conflicts with context-mode's PreCompact hook
-	// which needs compaction to run to build resume snapshots.
-	// Instead, we now prioritize crew state in the compaction summary (see startCompact).
+	// Phase 1.2: Always allow compaction to proceed.
+	// Previously this deferred compaction during foreground runs, but that prevented
+	// context-mode's PreCompact hook from running (which needs compaction to build resume snapshots).
+	// pi-crew state is preserved via customInstructions and artifactIndex appended above.
 	pi.on("session_before_compact", async (_event, ctx) => {
 		// Always allow compaction - context-mode needs it for resume snapshots
-		// pi-crew state is preserved via customInstructions and artifactIndex
 		return;
 	});
 
-	// Phase 2.1: Proactive compaction with dynamic threshold based on model context window.
+	// Phase 2.1: Proactive compaction with dynamic threshold.
+	// Only trigger compaction when context usage >=75%, or when deferred from a previous high-usage turn.
 	pi.on("turn_end", (_event, ctx) => {
 		if (compactionInProgress) return;
+		const hasActiveForeground = options.foregroundControllers.size > 0 || options.foregroundTeamRunControllers.size > 0;
 		const ratio = usageRatio(ctx);
+		// If deferred compaction is pending and foreground just ended, check if still needed
+		if (!hasActiveForeground && pendingCompactReason) {
+			pendingCompactReason = null;
+			// Only compact if ratio still >= TRIGGER_RATIO, otherwise skip
+			if (ratio === undefined || ratio < TRIGGER_RATIO) return;
+			startCompact(ctx, "deferred");
+			return;
+		}
 		if (ratio === undefined || ratio < TRIGGER_RATIO) return;
-		// Always allow compaction during foreground runs - context-mode needs it
-		startCompact(ctx, ratio >= HARD_RATIO ? "critical" : "threshold");
+		// During foreground run: defer unless context is critically full
+		if (hasActiveForeground) {
+			if (ratio >= HARD_RATIO) {
+				startCompact(ctx, "critical");
+			} else {
+				pendingCompactReason = "threshold-during-foreground-run";
+			}
+			return;
+		}
+		startCompact(ctx, "threshold");
 	});
 }

package/src/ui/crew-widget.ts

@@ -121,7 +121,10 @@ function agentActivity(agent: CrewAgentRecord, liveHandle?: LiveAgentHandle): st
 	}
 	if (agent.progress?.currentTool) return `${TOOL_LABELS[agent.progress.currentTool] ?? agent.progress.currentTool}…`;
 	const recent = agent.progress?.recentOutput?.at(-1);
-	if (recent) return recent.replace(/\s+/g, " ").trim();
+	if (recent) {
+		const cleaned = recent.replace(/\s+/g, " ").trim();
+		return cleaned.length > 60 ? cleaned.slice(0, 60) + "…" : cleaned;
+	}
 	if (agent.progress?.activityState === "needs_attention") return "needs attention";
 	if (agent.status === "queued") return "queued";
 	if (agent.status === "running") {
@@ -165,9 +168,20 @@ function agentStats(agent: CrewAgentRecord, liveHandle?: LiveAgentHandle): strin
 			// If distance to seconds is much smaller AND value is in valid seconds range
 			return distToSec < distToMs && distToSec < 31536000 * 2 && v > 1000000000;
 		};
-		const startedMs = isSeconds(rawStarted) ? rawStarted * 1000 : rawStarted;
-		const completedMs = isSeconds(rawCompleted) ? rawCompleted * 1000 : rawCompleted;
-		// Validate: startedAtMs should be within reasonable bounds
+		// Simple fix: detect if value is Unix seconds and convert properly
+		// Unix seconds are ~10 digits (e.g., 1779082445), Unix ms are ~13 digits (e.g., 1779082445000)
+		const toMs = (v: number): number => {
+			if (v <= 0) return 0;
+			// If 10 digits (or 9 with recent), treat as seconds
+			if (v > 1000000000 && v < 10000000000) return v * 1000;
+			// If 13 digits, treat as ms
+			if (v > 100000000000 && v < 10000000000000) return v;
+			// Fallback: use as-is
+			return v;
+		};
+		const startedMs = toMs(rawStarted);
+		const completedMs = rawCompleted > 0 ? toMs(rawCompleted) : 0;
+		// Validate bounds
 		const isValidStarted = startedMs > 0 && startedMs < nowMs + 60000 && startedMs > nowMs - 3155692600000;
 		const isValidCompleted = completedMs === 0 || (completedMs > 0 && completedMs < nowMs + 60000);
 		const ms = (isValidCompleted ? completedMs : nowMs) - (isValidStarted ? startedMs : nowMs);

package/src/ui/live-conversation-overlay.ts

@@ -68,15 +68,19 @@ export class LiveConversationOverlay {
 		const rawCompleted = act.completedAtMs || 0;
 		const nowMs = Date.now();
 		const nowSec = Math.floor(nowMs / 1000);
-		// Detect if value is in seconds vs milliseconds by comparing distance to current time
-		const isSeconds = (v: number) => {
-			if (v <= 0) return false;
-			const distToSec = Math.abs(v - nowSec);
-			const distToMs = Math.abs(v - nowMs);
-			return distToSec < distToMs && distToSec < 31536000 * 2 && v > 1000000000;
+		// Simple fix: detect if value is Unix seconds and convert properly
+		const toMs = (v: number): number => {
+			if (v <= 0) return 0;
+			// If 10 digits (or 9 with recent), treat as seconds
+			if (v > 1000000000 && v < 10000000000) return v * 1000;
+			// If 13 digits, treat as ms
+			if (v > 100000000000 && v < 10000000000000) return v;
+			// Fallback: use as-is
+			return v;
 		};
-		const startedMs = isSeconds(rawStarted) ? rawStarted * 1000 : rawStarted;
-		const completedMs = isSeconds(rawCompleted) ? rawCompleted * 1000 : rawCompleted;
+		const startedMs = toMs(rawStarted);
+		const completedMs = rawCompleted > 0 ? toMs(rawCompleted) : 0;
+		// Validate bounds
 		const isValidStarted = startedMs > 0 && startedMs < nowMs + 60000 && startedMs > nowMs - 3155692600000;
 		const isValidCompleted = completedMs === 0 || (completedMs > 0 && completedMs < nowMs + 60000);
 		return (isValidCompleted ? completedMs : nowMs) - (isValidStarted ? startedMs : nowMs);