pi-harness-runtime 0.5.0 → 0.6.3-beta.13

package/harness/context-window-manager.ts

@@ -3,24 +3,71 @@
  *
  * Manages context window usage across providers.
  * Tracks utilization and suggests strategies when approaching limits.
+ *
+ * Enhanced with:
+ * - Compact thresholds (proactive at 85%, blocking at 97%)
+ * - Circuit breaker for consecutive compact failures
+ * - Buffer-aware token estimation
  */
 
 import type {
+	ContextWindowUpdate,
 	ContextWindowStats,
 	ContextWindowConfig,
 	ProviderMessage,
+	CompactableMessage,
 } from "../packages/types/src/runtime-types.ts";
+import {
+	roughTokenCount,
+	roughMessagesTokens,
+} from "../packages/token-estimation/src/index.ts";
+
+// ─── Constants ────────────────────────────────────────────────────────────────
+
+/** Proactive compact triggers at this many tokens before limit */
+export const AUTOCOMPACT_BUFFER_TOKENS = 13_000;
+
+/** Warning threshold buffer */
+export const WARNING_THRESHOLD_BUFFER_TOKENS = 20_000;
+
+/** Blocking threshold buffer */
+export const BLOCKING_THRESHOLD_BUFFER_TOKENS = 20_000;
+
+/** Maximum consecutive compact failures before circuit breaker */
+export const MAX_CONSECUTIVE_COMPACT_FAILURES = 3;
+
+// ─── Types ──────────────────────────────────────────────────────────────────
 
-export interface ContextWindowUpdate {
-	provider: string;
-	model: string;
-	maxTokens: number;
-	usedTokens: number;
+export interface CompactThresholds {
+	/** Trigger proactive compact at this utilization (0.85) */
+	autoCompactAt: number;
+	/** Show warning at this utilization (0.80) */
+	warningAt: number;
+	/** Block API calls at this utilization (0.97) */
+	blockingAt: number;
+	/** Max compact retry attempts */
+	maxRetries: number;
+	/** Reserved tokens for output during compact */
+	reservedOutputTokens: number;
 }
 
+export interface TokenEstimate {
+	total: number;
+	bufferRemaining: number;
+	utilizationPct: number;
+	atRisk: boolean;
+	shouldCompact: boolean;
+	shouldBlock: boolean;
+}
+
+// ─── Context Window Manager ─────────────────────────────────────────────────
+
 export class ContextWindowManager {
 	private stats: Map<string, ContextWindowStats> = new Map();
 	private configs: Map<string, ContextWindowConfig> = new Map();
+	private consecutiveFailures = 0;
+	private lastCompactTimestamp = 0;
+	private modelContextWindows: Map<string, number> = new Map();
 
 	constructor(defaultConfigs?: Record<string, ContextWindowConfig>) {
 		// Initialize with defaults
@@ -48,6 +95,8 @@ export class ContextWindowManager {
 		}
 	}
 
+	// ─── Public API ───────────────────────────────────────────────────────────
+
 	/**
 	 * Update context window stats after a request
 	 */
@@ -98,6 +147,37 @@ export class ContextWindowManager {
 		return "ok";
 	}
 
+	/**
+	 * Get compact thresholds for a provider
+	 */
+	getCompactThresholds(provider: string): CompactThresholds {
+		const config = this.configs.get(provider);
+		return {
+			autoCompactAt: 0.85,
+			warningAt: config?.warningThreshold ?? 0.8,
+			blockingAt: config?.criticalThreshold ?? 0.97,
+			maxRetries: MAX_CONSECUTIVE_COMPACT_FAILURES,
+			reservedOutputTokens: 20_000,
+		};
+	}
+
+	/**
+	 * Get effective context window size (minus reserved output tokens)
+	 */
+	getEffectiveContextWindow(provider: string, model: string): number {
+		const key = `${provider}:${model}`;
+		const base = this.modelContextWindows.get(key) ?? 200_000;
+		const thresholds = this.getCompactThresholds(provider);
+		return base - thresholds.reservedOutputTokens;
+	}
+
+	/**
+	 * Set the context window size for a model
+	 */
+	setContextWindow(provider: string, model: string, maxTokens: number): void {
+		this.modelContextWindows.set(`${provider}:${model}`, maxTokens);
+	}
+
 	/**
 	 * Estimate remaining capacity
 	 */
@@ -111,6 +191,122 @@ export class ContextWindowManager {
 		return Math.floor(stats.availableTokens / avgTokensPerRequest);
 	}
 
+	/**
+	 * Estimate tokens with buffer awareness for compact decisions
+	 */
+	estimateTokensWithBuffer(opts: {
+		messages: CompactableMessage[];
+		tools?: Array<{
+			name: string;
+			description?: string;
+			input_schema?: Record<string, unknown>;
+		}>;
+		systemPrompt?: string;
+		provider: string;
+		model: string;
+	}): TokenEstimate {
+		const { messages, tools, systemPrompt, provider, model } = opts;
+
+		// Calculate message tokens
+		const messageTokens = roughMessagesTokens(
+			messages.map((m) => ({
+				role: m.role,
+				content: m.content,
+			})),
+		);
+
+		// Calculate tool tokens
+		const toolTokens = (tools ?? []).reduce(
+			(sum, tool) =>
+				sum +
+				roughTokenCount(tool.name) +
+				roughTokenCount(tool.description ?? "") +
+				roughTokenCount(JSON.stringify(tool.input_schema ?? {})),
+			0,
+		);
+
+		// Calculate system prompt tokens
+		const systemTokens = systemPrompt ? roughTokenCount(systemPrompt) : 0;
+
+		const total = messageTokens + toolTokens + systemTokens;
+		const effectiveWindow = this.getEffectiveContextWindow(provider, model);
+		const bufferRemaining = effectiveWindow - total;
+
+		// Determine if we should compact or block
+		const autoCompactTokens = effectiveWindow - AUTOCOMPACT_BUFFER_TOKENS;
+		const blockingTokens = effectiveWindow - BLOCKING_THRESHOLD_BUFFER_TOKENS;
+
+		const shouldCompact = total >= autoCompactTokens;
+		const shouldBlock = total >= blockingTokens;
+
+		return {
+			total,
+			bufferRemaining,
+			utilizationPct: total / effectiveWindow,
+			atRisk: bufferRemaining < AUTOCOMPACT_BUFFER_TOKENS,
+			shouldCompact,
+			shouldBlock,
+		};
+	}
+
+	/**
+	 * Check if we should trigger proactive compact
+	 */
+	shouldProactiveCompact(estimate: TokenEstimate): boolean {
+		return estimate.shouldCompact && !this.shouldCircuitBreak();
+	}
+
+	/**
+	 * Check if we should block (must compact before API call)
+	 */
+	shouldBlockApiCall(estimate: TokenEstimate): boolean {
+		return estimate.shouldBlock;
+	}
+
+	/**
+	 * Record a compact failure (for circuit breaker)
+	 */
+	recordCompactFailure(): number {
+		this.consecutiveFailures++;
+		return this.consecutiveFailures;
+	}
+
+	/**
+	 * Record a compact success (reset circuit breaker)
+	 */
+	recordCompactSuccess(): void {
+		this.consecutiveFailures = 0;
+		this.lastCompactTimestamp = Date.now();
+	}
+
+	/**
+	 * Check if circuit breaker should activate
+	 */
+	shouldCircuitBreak(): boolean {
+		return this.consecutiveFailures >= MAX_CONSECUTIVE_COMPACT_FAILURES;
+	}
+
+	/**
+	 * Get consecutive failure count
+	 */
+	getConsecutiveFailures(): number {
+		return this.consecutiveFailures;
+	}
+
+	/**
+	 * Reset circuit breaker
+	 */
+	resetCircuitBreaker(): void {
+		this.consecutiveFailures = 0;
+	}
+
+	/**
+	 * Get time since last compact (ms)
+	 */
+	getTimeSinceLastCompact(): number {
+		return Date.now() - this.lastCompactTimestamp;
+	}
+
 	/**
 	 * Prepare messages for a request (truncation/summarization strategy)
 	 */
@@ -129,32 +325,21 @@ export class ContextWindowManager {
 			return messages;
 		}
 
-		switch (strategy) {
-			case "truncate": {
-				// Remove oldest messages first
-				const truncated = [...messages];
-				while (totalTokens > maxTokens && truncated.length > 1) {
-					const removed = truncated.shift();
-					if (removed) {
-						totalTokens -= estimateTokens(removed.content);
-					}
+		if (strategy === "truncate") {
+			// Remove oldest messages first
+			const truncated = [...messages];
+			while (totalTokens > maxTokens && truncated.length > 1) {
+				const removed = truncated.shift();
+				if (removed) {
+					totalTokens -= estimateTokens(removed.content);
 				}
-				return truncated;
 			}
-
-			case "summarize":
-				// In a real implementation, this would use a summarization LLM
-				// For now, fall back to truncate
-				return this.prepareMessages(messages, maxTokens, "truncate");
-
-			case "split":
-				// Split into multiple requests if possible
-				// Return first portion
-				return this.prepareMessages(messages, maxTokens, "truncate");
-
-			default:
-				return messages;
+			return truncated;
 		}
+
+		// summarize and split both fall back to truncate for now
+		// In a real implementation, split would return multiple message batches
+		return this.prepareMessages(messages, maxTokens, "truncate");
 	}
 
 	/**
@@ -177,7 +362,7 @@ export class ContextWindowManager {
 	generateReport(): string {
 		const lines = ["Context Window Utilization Report", "=".repeat(40), ""];
 
-		for (const [key, stats] of this.stats.entries()) {
+		for (const [, stats] of this.stats.entries()) {
 			const config = this.configs.get(stats.provider);
 			const bar = this.renderBar(stats.utilizationPct);
 			const status = this.getUtilizationStatus(stats.provider, stats.model);
@@ -199,6 +384,11 @@ export class ContextWindowManager {
 			lines.push("");
 		}
 
+		// Add circuit breaker status
+		lines.push("Circuit Breaker Status", "-".repeat(20));
+		lines.push(`Consecutive failures: ${this.consecutiveFailures}`);
+		lines.push(`Circuit broken: ${this.shouldCircuitBreak() ? "YES ⚠️" : "No"}`);
+
 		return lines.join("\n");
 	}
 
@@ -208,3 +398,67 @@ export class ContextWindowManager {
 		return "[" + "█".repeat(filled) + "░".repeat(empty) + "]";
 	}
 }
+
+// ─── Microcompact Helpers ───────────────────────────────────────────────────
+
+/**
+ * Microcompact: prune old tool results based on time gap.
+ * Returns the number of tokens freed.
+ */
+export function microcompactToolResults(
+	messages: CompactableMessage[],
+	options: {
+		maxAgeMs?: number;
+		keepRecent?: number;
+	} = {},
+): number {
+	const maxAgeMs = options.maxAgeMs ?? 30 * 60 * 1000; // 30 minutes
+	const keepRecent = options.keepRecent ?? 2;
+
+	const now = Date.now();
+	let freedTokens = 0;
+
+	for (const msg of messages) {
+		if (msg.role !== "assistant" || !msg.toolResults) continue;
+
+		// Sort by timestamp, newest first
+		const sorted = [...msg.toolResults].sort(
+			(a, b) => b.timestamp - a.timestamp,
+		);
+
+		// Keep IDs of recent tool results
+		const keepIds = new Set(sorted.slice(0, keepRecent).map((r) => r.id));
+
+		// Prune old ones
+		for (const tr of msg.toolResults) {
+			if (!keepIds.has(tr.id) && now - tr.timestamp > maxAgeMs) {
+				freedTokens += tr.tokens;
+				// Truncate content but keep marker
+				tr.content = "[Old tool result cleared]";
+				tr.tokens = 0;
+			}
+		}
+	}
+
+	return freedTokens;
+}
+
+/**
+ * Parse token gap from a prompt-too-long error message.
+ * Returns the gap (excess tokens) or undefined if unparseable.
+ */
+export function parseTokenGapFromError(
+	errorMessage: string,
+): number | undefined {
+	// Match patterns like: "137500 tokens > 135000 maximum"
+	const match = errorMessage.match(
+		/prompt is too long[^0-9]*(\d+)\s*tokens?\s*>\s*(\d+)/i,
+	);
+	if (match) {
+		const actual = parseInt(match[1], 10);
+		const limit = parseInt(match[2], 10);
+		const gap = actual - limit;
+		return gap > 0 ? gap : undefined;
+	}
+	return undefined;
+}

package/harness/continue-prompt.ts

@@ -0,0 +1,242 @@
+/**
+ * Continue Prompt Generator — RFC-0029
+ *
+ * Generates context-aware continue prompts after compaction.
+ * Based on the reference implementation's buildContinuePrompt() pattern.
+ */
+
+import type { CompactableMessage } from "../packages/types/src/runtime-types.js";
+
+// ─── Types ──────────────────────────────────────────────────────────────────
+
+export interface ContinueContext {
+	/** Task identifier */
+	taskId: string;
+	/** Original task requirement */
+	requirement: string;
+	/** What was already completed */
+	whatWasCompleted: string[];
+	/** What still needs to be done */
+	whatNeedsToBeDone: string[];
+	/** Files that may have partial content */
+	partialFiles: string[];
+	/** Key decisions made */
+	decisions: string[];
+	/** Suggested next step */
+	nextStep?: string;
+	/** Current working directory */
+	workingDir?: string;
+}
+
+export interface MinimalContinueContext {
+	/** LLM-generated summary */
+	summary: string;
+	/** Recent messages to preserve */
+	recentMessages: CompactableMessage[];
+}
+
+// ─── Continue Prompt Generator ───────────────────────────────────────────────
+
+export class ContinuePromptGenerator {
+	/**
+	 * Generate a comprehensive continue prompt for post-compact resume
+	 */
+	generate(context: ContinueContext): string {
+		const parts: string[] = [
+			"# Continue Previous Task",
+			"",
+			"## Task",
+			context.requirement,
+			"",
+		];
+
+		if (context.whatWasCompleted.length > 0) {
+			parts.push("## What Was Completed");
+			for (const item of context.whatWasCompleted) {
+				parts.push(`- ${item}`);
+			}
+			parts.push("");
+		}
+
+		if (context.partialFiles.length > 0) {
+			parts.push("## Partial Files Created");
+			parts.push("Review these files — they may contain incomplete work:");
+			for (const file of context.partialFiles) {
+				parts.push(`- ${file}`);
+			}
+			parts.push("");
+		}
+
+		if (context.decisions.length > 0) {
+			parts.push("## Key Decisions");
+			for (const decision of context.decisions) {
+				parts.push(`- ${decision}`);
+			}
+			parts.push("");
+		}
+
+		if (context.whatNeedsToBeDone.length > 0) {
+			parts.push("## What Needs To Be Done");
+			for (const item of context.whatNeedsToBeDone) {
+				parts.push(`- ${item}`);
+			}
+			parts.push("");
+		}
+
+		parts.push(
+			"## Instructions",
+			"",
+			"1. Review any partial files created above",
+			"2. Continue from where the previous session ended",
+			"3. Complete the remaining work listed in 'What Needs To Be Done'",
+			"4. Ensure all tests pass before marking complete",
+			"",
+			"**Do not repeat work that was already completed.**",
+			"",
+		);
+
+		if (context.nextStep) {
+			parts.push("## Suggested Next Step");
+			parts.push(context.nextStep);
+		}
+
+		if (context.workingDir) {
+			parts.push("", `Working directory: \`${context.workingDir}\``);
+		}
+
+		return parts.join("\n");
+	}
+
+	/**
+	 * Generate a minimal continue message for quick resume
+	 */
+	generateMinimal(context: MinimalContinueContext): string {
+		const recent = context.recentMessages
+			.slice(-5)
+			.map((m) => `[${m.role}]\n${this.truncateContent(m.content, 500)}`)
+			.join("\n\n");
+
+		return [
+			"Continue from where you left off.",
+			"",
+			"## Summary of Earlier Work",
+			context.summary,
+			"",
+			"## Recent Context",
+			recent,
+			"",
+			"**Do not repeat work already done.** Focus on completing the remaining work.",
+		].join("\n");
+	}
+
+	/**
+	 * Generate a compact boundary message for message history
+	 */
+	generateBoundary(options: {
+		summary: string;
+		reason: string;
+		messagesCompacted: number;
+	}): string {
+		return [
+			"## Earlier Conversation Summarized",
+			"",
+			`[Compacted due to: ${options.reason}]`,
+			`[${options.messagesCompacted} messages summarized]`,
+			"",
+			options.summary,
+			"",
+			"## Resume Point",
+			"Continue from the messages below.",
+		].join("\n");
+	}
+
+	/**
+	 * Extract continue context from compact result
+	 */
+	static fromCompactResult(
+		result: {
+			summary?: string;
+			messagesCompacted: number;
+			trigger: string;
+		},
+		task: {
+			id: string;
+			requirement: string;
+		},
+	): ContinueContext {
+		return {
+			taskId: task.id,
+			requirement: task.requirement,
+			whatWasCompleted: result.summary
+				? ContinuePromptGenerator.extractCompletedWork(result.summary)
+				: [],
+			whatNeedsToBeDone: ["Continue from where the conversation was compacted"],
+			partialFiles: [],
+			decisions: result.summary
+				? ContinuePromptGenerator.extractDecisions(result.summary)
+				: [],
+		};
+	}
+
+	/**
+	 * Extract completed work items from summary text
+	 */
+	private static extractCompletedWork(summary: string): string[] {
+		const completed: string[] = [];
+
+		// Look for patterns indicating completed work
+		const patterns = [
+			/completed?:?\s*([^\n.]+)/gi,
+			/created?:?\s*([^\n.]+)/gi,
+			/implemented?:?\s*([^\n.]+)/gi,
+			/fixed?:?\s*([^\n.]+)/gi,
+			/passed?:?\s*([^\n.]+)/gi,
+		];
+
+		for (const pattern of patterns) {
+			for (const match of summary.matchAll(pattern)) {
+				if (match[1]) {
+					completed.push(match[1].trim());
+				}
+			}
+		}
+
+		return completed.slice(0, 5);
+	}
+
+	/**
+	 * Extract decisions from summary text
+	 */
+	private static extractDecisions(summary: string): string[] {
+		const decisions: string[] = [];
+
+		const patterns = [
+			/decided?:?\s*([^\n.]+)/gi,
+			/chose?:?\s*([^\n.]+)/gi,
+			/approach?:?\s*([^\n.]+)/gi,
+			/using?:?\s*([^\n.]+)/gi,
+		];
+
+		for (const pattern of patterns) {
+			for (const match of summary.matchAll(pattern)) {
+				if (match[1]) {
+					decisions.push(match[1].trim());
+				}
+			}
+		}
+
+		return decisions.slice(0, 5);
+	}
+
+	/**
+	 * Truncate content to max length
+	 */
+	private truncateContent(content: string, maxLength: number): string {
+		if (content.length <= maxLength) return content;
+		return content.substring(0, maxLength) + "... [truncated]";
+	}
+}
+
+// ─── Singleton Instance ──────────────────────────────────────────────────────
+
+export const continuePromptGenerator = new ContinuePromptGenerator();

package/harness/e2e/minimax-quota-parser.ts

@@ -0,0 +1,88 @@
+export interface ParsedMiniMaxQuotaData {
+	h5UsedPct?: number;
+	h5ResetsAt?: string;
+	weeklyUsedPct?: number;
+	weeklyResetsAt?: string;
+	monthlyUsedPct?: number;
+	monthlyResetsAt?: string;
+	creditBalance?: string;
+	tokenUsage?: {
+		currentMonth: string;
+		last7Days: string;
+		last30Days: string;
+		total: string;
+	};
+}
+
+/**
+ * Strip trailing timestamp / reset-window noise that flattened innerText
+ * concatenates onto values (e.g. "1 day 13 hr 00 UTC", "No credits yet 00 UTC").
+ */
+function stripTrailingNoise(value: string): string {
+	return value
+		.replace(/\s+\d{1,2}(?::\d{2})?\s+UTC.*$/i, "")
+		.replace(/\s+UTC.*$/i, "")
+		.replace(/\s+resets?\s+in\s+.*$/i, "")
+		.replace(/\s*\.{2,}.*$/, "")
+		.trim();
+}
+
+/**
+ * Parse quota data from visible MiniMax usage page text.
+ */
+export function parseMiniMaxQuotaText(text: string): ParsedMiniMaxQuotaData {
+	const data: ParsedMiniMaxQuotaData = {};
+	const normalized = text.replace(/\r/g, "");
+
+	const h5Match = normalized.match(
+		/5h(?:\s+limit)?[\s\S]{0,200}?Used\s*(\d+(?:\.\d+)?)\s*%/i,
+	);
+	if (h5Match) {
+		data.h5UsedPct = parseFloat(h5Match[1]);
+	}
+
+	const h5ResetMatch = normalized.match(
+		/5h(?:\s+limit)?[\s\S]{0,200}?Resets?\s+in\s+([^\n%]+)/i,
+	);
+	if (h5ResetMatch) {
+		data.h5ResetsAt = stripTrailingNoise(h5ResetMatch[1]);
+	}
+
+	const weeklyMatch = normalized.match(
+		/week(?:ly)?(?:\s+limit)?[\s\S]{0,200}?Used\s*(\d+(?:\.\d+)?)\s*%/i,
+	);
+	if (weeklyMatch) {
+		data.weeklyUsedPct = parseFloat(weeklyMatch[1]);
+	}
+
+	const weeklyResetMatch = normalized.match(
+		/week(?:ly)?(?:\s+limit)?[\s\S]{0,200}?Resets?\s+in\s+([^\n%]+)/i,
+	);
+	if (weeklyResetMatch) {
+		data.weeklyResetsAt = stripTrailingNoise(weeklyResetMatch[1]);
+	}
+
+	const creditMatch = normalized.match(
+		/credit(?:\s+balance)?[^:\n]*:\s*([^\n]+)/i,
+	);
+	if (creditMatch) {
+		const cleaned = stripTrailingNoise(creditMatch[1]);
+		if (cleaned) {
+			data.creditBalance = cleaned;
+		}
+	}
+
+	const tokenSectionMatch = normalized.match(
+		/token[^:]*:?\s*([\d.,]+\s*(?:M|B|K)?\s*tokens?)/gi,
+	);
+	if (tokenSectionMatch) {
+		data.tokenUsage = {
+			currentMonth: tokenSectionMatch[0] || "",
+			last7Days: tokenSectionMatch[1] || "",
+			last30Days: tokenSectionMatch[2] || "",
+			total: tokenSectionMatch[3] || "",
+		};
+	}
+
+	return data;
+}