pi-harness-runtime 0.3.2-beta.2 → 0.4.0

package/CHANGELOG.md

@@ -1,11 +1,25 @@
 # Changelog
 
-All notable changes to `pi-harness-runtime` will be documented in this file.
+All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+## [0.4.0](https://github.com/ManotLuijiu/pi-harness-runtime/compare/v0.3.1...v0.4.0) (2026-07-05)
 
-## [Unreleased]
+
+### Features
+
+* **auth:** Add curator-mode MiniMax browser authentication ([4914517](https://github.com/ManotLuijiu/pi-harness-runtime/commit/49145171d0205e78454472f5f4e540ff7c70a711))
+* **auth:** Add MiniMax browser authentication prototype ([75e294e](https://github.com/ManotLuijiu/pi-harness-runtime/commit/75e294e31f582521a48b66d1ce05e1cc3f581750))
+* **auth:** Add persistent browser profile auth for MiniMax ([f725d2b](https://github.com/ManotLuijiu/pi-harness-runtime/commit/f725d2b89aa61d6e1cd5de0458b4d2c80efb6e7a))
+* Fixed Chrome ([98becb8](https://github.com/ManotLuijiu/pi-harness-runtime/commit/98becb8bed6b94612db648d4bdd58f8a45d23040))
+* implement RFC-0019 through RFC-0022 ([4468dcb](https://github.com/ManotLuijiu/pi-harness-runtime/commit/4468dcb1cfcb320f8eeab50c8ef590de74de979a))
+
+
+### Bug Fixes
+
+* **auth:** Don't re-navigate after login detection ([133e6d5](https://github.com/ManotLuijiu/pi-harness-runtime/commit/133e6d5ac852cc3048881eb4e28700c3aceca792))
+* **auth:** Poll for content AND URL, log URL changes for debugging ([4a197fe](https://github.com/ManotLuijiu/pi-harness-runtime/commit/4a197febec24efe85568c3ce35286f45602f5e23))
+* **auth:** Poll URL instead of stdin for login detection ([04ced9a](https://github.com/ManotLuijiu/pi-harness-runtime/commit/04ced9a76753e6b6d4b8e43c97fe19830ab08af1))
+* **skill:** Add description field to harness-runtime SKILL.md ([d06d37b](https://github.com/ManotLuijiu/pi-harness-runtime/commit/d06d37becfd92e17ffe27dfbeac04da61f0d89df))
 
 ## [0.2.0] - 2026-06-29
 

package/README.md

@@ -178,3 +178,23 @@ MIT © 2026 MooCoding
 - [pi-coding-agent](https://github.com/earendil-works/pi-coding-agent) — Underlying pi agent
 - [context-mode](https://github.com/MiniMax-AI/context-mode) — Context window tracking
 - [pi-web-access](https://github.com/nicobailon/pi-web-access) — Web search for pi
+
+Day 6 adds runtime recovery and remote-observability architecture.
+
+## RFCs
+
+- RFC-0019 Auto Compact and Continue
+- RFC-0020 Output Token Limit Handler
+- RFC-0021 Partial Response Recovery
+- RFC-0022 Notification Center
+- RFC-0023 Local Browser Agent
+
+## Why this matters
+
+These RFCs address real runtime failures:
+
+- MiniMax auto-compacts but does not automatically resume.
+- A model may stop because max output token limit is reached.
+- Partial responses must be preserved and continued.
+- The human needs mobile/tablet notifications.
+- Headless servers cannot open interactive login windows for MiniMax usage console.

package/harness/auto-compact.ts

@@ -0,0 +1,326 @@
+/**
+ * Auto Compact and Continue — RFC-0019
+ *
+ * Automatically resume work after model/session compaction without requiring
+ * human intervention. Keeps the human out of the message-bus role.
+ *
+ * Artifact Layout:
+ *   harness/context/
+ *     compaction_events.jsonl
+ *     latest_compaction_summary.md
+ *     continue_prompt.md
+ */
+
+import {
+	appendFileSync,
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+export interface CompactionEvent {
+	timestamp: string;
+	jobId: string;
+	taskId: string;
+	compactedFromTokens: number;
+	reason: string;
+	errorMessage?: string;
+	partialOutput?: string;
+	continuePrompt?: string;
+}
+
+export interface CompactionConfig {
+	jobId: string;
+	rootDir?: string;
+	maxContinueAttempts?: number;
+	continuationBackoffMs?: number;
+}
+
+export interface ContinuePrompt {
+	taskId: string;
+	originalRequirement: string;
+	whatWasCompleted: string;
+	whatNeedsToBeDone: string;
+	partialFiles: string[];
+	nextSteps: string;
+}
+
+const COMPACTION_PATTERNS = [
+	/\[compaction\]/i,
+	/compacted from \d+[,.]?\d* tokens/i,
+	/model stopped because it reached the maximum output token limit/i,
+	/error.*output.*token.*limit/i,
+	/context.*truncated/i,
+	/session.*compact/i,
+];
+
+const CONTINUE_MARKERS = [
+	/would you like me to continue/i,
+	/should i continue/i,
+	/type.*continue/i,
+	/\[continue\]/i,
+	/waiting for your response/i,
+];
+
+export class AutoCompactEngine {
+	private readonly rootDir: string;
+	private readonly jobId: string;
+	private readonly maxAttempts: number;
+	private readonly backoffMs: number;
+	private continueAttempts = 0;
+
+	constructor(config: CompactionConfig) {
+		this.rootDir =
+			config.rootDir ??
+			join(homedir(), ".pi", "harness", config.jobId, "context");
+		this.jobId = config.jobId;
+		this.maxAttempts = config.maxContinueAttempts ?? 5;
+		this.backoffMs = config.continuationBackoffMs ?? 1000;
+	}
+
+	/**
+	 * Detect if output contains compaction markers
+	 */
+	detectCompaction(output: string): boolean {
+		return COMPACTION_PATTERNS.some((pattern) => pattern.test(output));
+	}
+
+	/**
+	 * Detect if output is waiting for continue signal
+	 */
+	isWaitingForContinue(output: string): boolean {
+		return CONTINUE_MARKERS.some((pattern) => pattern.test(output));
+	}
+
+	/**
+	 * Parse compaction details from output
+	 */
+	parseCompactionEvent(output: string, taskId: string): CompactionEvent | null {
+		const lines = output.split("\n");
+		let compactedFromTokens = 0;
+		let reason = "unknown";
+		let errorMessage: string | undefined;
+
+		// Extract compacted token count
+		const tokenMatch = output.match(
+			/compacted from ([,\d]+(?:\.\d+)?)\s*tokens/i,
+		);
+		if (tokenMatch) {
+			compactedFromTokens = parseInt(tokenMatch[1].replace(/,/g, ""), 10);
+		}
+
+		// Extract reason
+		if (/output.*token.*limit/i.test(output)) {
+			reason = "output_token_limit";
+		} else if (/context.*truncated/i.test(output)) {
+			reason = "context_truncated";
+		} else if (/session.*compact/i.test(output)) {
+			reason = "session_compact";
+		}
+
+		// Extract error message
+		const errorMatch = output.match(/error[:\s]+(.+)/i);
+		if (errorMatch) {
+			errorMessage = errorMatch[1].trim();
+		}
+
+		return {
+			timestamp: new Date().toISOString(),
+			jobId: this.jobId,
+			taskId,
+			compactedFromTokens,
+			reason,
+			errorMessage,
+			partialOutput: output,
+		};
+	}
+
+	/**
+	 * Save compaction artifact
+	 */
+	saveCompactionArtifact(event: CompactionEvent): void {
+		this.ensureDir();
+
+		// Append to events log
+		const eventsPath = join(this.rootDir, "compaction_events.jsonl");
+		appendFileSync(eventsPath, JSON.stringify(event) + "\n", "utf-8");
+
+		// Write latest summary
+		const summaryPath = join(this.rootDir, "latest_compaction_summary.md");
+		const summary = this.generateSummary(event);
+		writeFileSync(summaryPath, summary, "utf-8");
+	}
+
+	/**
+	 * Generate continue prompt
+	 */
+	generateContinuePrompt(
+		taskId: string,
+		completedWork: string,
+		remainingWork: string,
+	): ContinuePrompt {
+		const prompt: ContinuePrompt = {
+			taskId,
+			originalRequirement: this.getRequirement(),
+			whatWasCompleted: completedWork,
+			whatNeedsToBeDone: remainingWork,
+			partialFiles: this.findPartialFiles(),
+			nextSteps: remainingWork,
+		};
+
+		const promptPath = join(this.rootDir, "continue_prompt.md");
+		const promptContent = this.formatContinuePrompt(prompt);
+		writeFileSync(promptPath, promptContent, "utf-8");
+
+		return prompt;
+	}
+
+	/**
+	 * Check if we should continue (respects max attempts)
+	 */
+	shouldContinue(): boolean {
+		this.continueAttempts++;
+		return this.continueAttempts <= this.maxAttempts;
+	}
+
+	/**
+	 * Get current continue attempt count
+	 */
+	getContinueAttempts(): number {
+		return this.continueAttempts;
+	}
+
+	/**
+	 * Reset continue attempts
+	 */
+	resetAttempts(): void {
+		this.continueAttempts = 0;
+	}
+
+	/**
+	 * Build the continue message for the next turn
+	 */
+	buildContinueMessage(): string {
+		const promptPath = join(this.rootDir, "continue_prompt.md");
+		if (existsSync(promptPath)) {
+			const prompt = readFileSync(promptPath, "utf-8");
+			return `continue\n\n${prompt}`;
+		}
+		return "continue";
+	}
+
+	// ─── Private Methods ────────────────────────────────────────────────
+
+	private ensureDir(): void {
+		if (!existsSync(this.rootDir)) {
+			mkdirSync(this.rootDir, { recursive: true });
+		}
+	}
+
+	private generateSummary(event: CompactionEvent): string {
+		return `# Compaction Summary
+
+**Time:** ${event.timestamp}
+**Job:** ${event.jobId}
+**Task:** ${event.taskId}
+**Reason:** ${event.reason}
+**Tokens Compacted:** ${event.compactedFromTokens.toLocaleString()}
+
+${event.errorMessage ? `**Error:** ${event.errorMessage}` : ""}
+
+## What Happened
+
+Session was compacted due to ${event.reason}.
+
+${
+	event.compactedFromTokens > 0
+		? `Context was reduced from approximately ${event.compactedFromTokens.toLocaleString()} tokens.`
+		: "Context was compacted."
+}
+
+## Next Step
+
+Runtime will automatically continue this task.
+
+Continue attempts: ${this.continueAttempts}/${this.maxAttempts}
+`;
+	}
+
+	private formatContinuePrompt(prompt: ContinuePrompt): string {
+		const lines = [
+			"# Continue Previous Task",
+			"",
+			"## Task Context",
+			"",
+			"**Requirement:** " + prompt.originalRequirement,
+			"",
+			"## What Was Completed",
+			"",
+			prompt.whatWasCompleted ||
+				"Work was in progress when session was compacted.",
+			"",
+		];
+
+		if (prompt.partialFiles.length > 0) {
+			lines.push("## Partial Files Created");
+			lines.push("");
+			for (const file of prompt.partialFiles) {
+				lines.push(`- ${file}`);
+			}
+			lines.push("");
+		}
+
+		lines.push("## What Needs To Be Done");
+		lines.push("");
+		lines.push(
+			prompt.whatNeedsToBeDone || "Continue the task from where it left off.",
+		);
+		lines.push("");
+		lines.push("## Instructions");
+		lines.push("");
+		lines.push("1. Review any partial files created");
+		lines.push("2. Continue from where the previous session ended");
+		lines.push("3. Complete the remaining work");
+		lines.push("4. Ensure all tests pass");
+		lines.push("");
+		lines.push("**Do not repeat work that was already completed.**");
+
+		return lines.join("\n");
+	}
+
+	private getRequirement(): string {
+		const checkpointPath = join(
+			homedir(),
+			".pi",
+			"harness",
+			this.jobId,
+			"checkpoint.json",
+		);
+		if (existsSync(checkpointPath)) {
+			try {
+				const checkpoint = JSON.parse(readFileSync(checkpointPath, "utf-8"));
+				return checkpoint.requirement ?? "Unknown requirement";
+			} catch {
+				return "Unknown requirement";
+			}
+		}
+		return "Unknown requirement";
+	}
+
+	private findPartialFiles(): string[] {
+		const partialDir = join(this.rootDir, "..", "partial", this.jobId);
+		if (!existsSync(partialDir)) {
+			return [];
+		}
+
+		try {
+			const files = readFileSync(join(partialDir, "files.json"), "utf-8");
+			return JSON.parse(files) as string[];
+		} catch {
+			return [];
+		}
+	}
+}

package/harness/e2e/index.ts

@@ -0,0 +1,44 @@
+/**
+ * E2E Test Engine — RFC-0013
+ *
+ * Browser-based end-to-end testing before work is marked ready for client.
+ *
+ * @example
+ * ```typescript
+ * import { E2ETestEngine, PlaywrightE2ERunner } from "./e2e/index.js";
+ *
+ * const runner = new PlaywrightE2ERunner({ headless: true });
+ * await runner.start();
+ *
+ * const engine = new E2ETestEngine("/tmp/e2e", {
+ *   baseUrl: "http://localhost:3000",
+ *   screenshotOnFailure: true,
+ * });
+ * engine.setRunner(runner);
+ *
+ * const scenario = engine.createScenario(
+ *   "homepage-loads",
+ *   "Homepage Loads",
+ *   "Verify the homepage loads correctly",
+ * );
+ * engine.addStep(scenario, "navigate", { value: "http://localhost:3000" });
+ * engine.addStep(scenario, "wait", { selector: "h1" });
+ * engine.addStep(scenario, "assert", { assertCondition: "document.querySelector('h1') !== null" });
+ *
+ * const result = await engine.runScenario(scenario);
+ * console.log(result);
+ *
+ * await runner.stop();
+ * ```
+ */
+
+export { E2ETestEngine } from "./test-engine.js";
+export {
+	PlaywrightE2ERunner,
+	MiniMaxQuotaScraper,
+} from "./playwright-runner.js";
+export type {
+	E2ERunner,
+	PlaywrightRunnerConfig,
+	QuotaPageData,
+} from "./playwright-runner.js";

package/harness/e2e/playwright-runner.ts

@@ -7,35 +7,40 @@
  * Also used as the E2E runner for testing workflows.
  */
 
+// Dynamic import for Playwright (optional dependency)
+let playwrightModule: typeof import("playwright") | null = null;
+
+async function getPlaywright() {
+	if (!playwrightModule) {
+		try {
+			playwrightModule = await import("playwright");
+		} catch {
+			console.warn(
+				"[PlaywrightRunner] Playwright not installed. E2E tests will be skipped.",
+			);
+			return null;
+		}
+	}
+	return playwrightModule;
+}
+
 export interface PlaywrightRunnerConfig {
 	headless?: boolean;
 	slowMo?: number;
 	timeout?: number;
 	browser?: "chromium" | "firefox" | "webkit";
 	profileDir?: string;
+	viewport?: { width: number; height: number };
 }
 
-export interface PlaywrightBrowser {
-	new (config?: PlaywrightRunnerConfig): PlaywrightBrowserInstance;
-}
-
-export interface PlaywrightBrowserInstance {
-	page(): PlaywrightPage;
-	close(): Promise<void>;
-}
-
-export interface PlaywrightPage {
-	goto(url: string): Promise<void>;
+// Forward-compatible runner interface for E2E Test Engine
+export interface E2ERunner {
+	navigate(url: string): Promise<void>;
 	click(selector: string): Promise<void>;
-	fill(selector: string, value: string): Promise<void>;
-	waitForSelector(
-		selector: string,
-		options?: { timeout?: number },
-	): Promise<void>;
-	screenshot(options?: { path?: string }): Promise<void>;
-	evaluate<T>(fn: (...args: unknown[]) => T, ...args: unknown[]): Promise<T>;
-	content(): Promise<string>;
-	url(): Promise<string>;
+	type(selector: string, text: string): Promise<void>;
+	wait(selector: string, timeout?: number): Promise<void>;
+	screenshot(path: string): Promise<void>;
+	assert(condition: string, message?: string): Promise<boolean>;
 }
 
 export interface QuotaPageData {
@@ -81,10 +86,7 @@ export class MiniMaxQuotaScraper {
 	/**
 	 * Wait for quota data to load
 	 */
-	async waitForQuotaLoad(
-		page: PlaywrightPage,
-		timeoutMs?: number,
-	): Promise<void> {
+	async waitForQuotaLoad(page: any, timeoutMs?: number): Promise<void> {
 		const selectors = [
 			".quota-used",
 			".usage-percentage",
@@ -133,11 +135,14 @@ export class MiniMaxQuotaScraper {
 
 /**
  * Playwright E2E Runner for testing workflows
+ *
+ * Real implementation using Playwright library.
  */
-export class PlaywrightE2ERunner {
+export class PlaywrightE2ERunner implements E2ERunner {
 	private config: PlaywrightRunnerConfig;
-	private browser: PlaywrightBrowserInstance | null = null;
-	private page: PlaywrightPage | null = null;
+	private browser: any = null;
+	private context: any = null;
+	private page: any = null;
 
 	constructor(config: PlaywrightRunnerConfig = {}) {
 		this.config = {
@@ -153,9 +158,30 @@ export class PlaywrightE2ERunner {
 	 * Start the browser
 	 */
 	async start(): Promise<void> {
-		// In a real implementation, this would launch Playwright
-		// this.browser = await chromium.launch({ headless: this.config.headless });
-		// this.page = await this.browser.newPage();
+		const pw = await getPlaywright();
+		if (!pw) {
+			throw new Error(
+				"Playwright not available. Install with: bun add playwright",
+			);
+		}
+
+		const browserType =
+			this.config.browser === "firefox"
+				? pw.firefox
+				: this.config.browser === "webkit"
+					? pw.webkit
+					: pw.chromium;
+
+		this.browser = await browserType.launch({
+			headless: this.config.headless,
+			slowMo: this.config.slowMo,
+		});
+
+		this.context = await this.browser.newContext({
+			viewport: this.config.viewport ?? { width: 1280, height: 720 },
+		});
+
+		this.page = await this.context.newPage();
 	}
 
 	/**
@@ -163,11 +189,15 @@ export class PlaywrightE2ERunner {
 	 */
 	async stop(): Promise<void> {
 		if (this.page) {
-			// await this.page.close();
+			await this.page.close();
 			this.page = null;
 		}
+		if (this.context) {
+			await this.context.close();
+			this.context = null;
+		}
 		if (this.browser) {
-			// await this.browser.close();
+			await this.browser.close();
 			this.browser = null;
 		}
 	}
@@ -177,7 +207,7 @@ export class PlaywrightE2ERunner {
 	 */
 	async navigate(url: string): Promise<void> {
 		if (!this.page) throw new Error("Browser not started");
-		await this.page.goto(url);
+		await this.page.goto(url, { timeout: this.config.timeout });
 	}
 
 	/**
@@ -190,12 +220,12 @@ export class PlaywrightE2ERunner {
 	}
 
 	/**
-	 * Fill an input
+	 * Type text into an input
 	 */
-	async fill(selector: string, value: string): Promise<void> {
+	async type(selector: string, text: string): Promise<void> {
 		if (!this.page) throw new Error("Browser not started");
 		await this.page.waitForSelector(selector, { timeout: this.config.timeout });
-		await this.page.fill(selector, value);
+		await this.page.fill(selector, text);
 	}
 
 	/**
@@ -213,23 +243,7 @@ export class PlaywrightE2ERunner {
 	 */
 	async screenshot(path: string): Promise<void> {
 		if (!this.page) throw new Error("Browser not started");
-		await this.page.screenshot({ path });
-	}
-
-	/**
-	 * Evaluate JavaScript
-	 */
-	async evaluate<T>(fn: () => T): Promise<T> {
-		if (!this.page) throw new Error("Browser not started");
-		return this.page.evaluate(fn);
-	}
-
-	/**
-	 * Get current URL
-	 */
-	async getUrl(): Promise<string> {
-		if (!this.page) throw new Error("Browser not started");
-		return this.page.url();
+		await this.page.screenshot({ path, fullPage: true });
 	}
 
 	/**
@@ -249,4 +263,29 @@ export class PlaywrightE2ERunner {
 
 		return result;
 	}
+
+	/**
+	 * Get the underlying page for advanced operations
+	 */
+	getPage() {
+		return this.page;
+	}
+
+	/**
+	 * Start tracing for debugging
+	 */
+	async startTracing(_outputPath: string): Promise<void> {
+		if (!this.page) throw new Error("Browser not started");
+		await this.page
+			.context()
+			.tracing.start({ screenshots: true, snapshots: true });
+	}
+
+	/**
+	 * Stop tracing and save
+	 */
+	async stopTracing(outputPath: string): Promise<void> {
+		if (!this.page) throw new Error("Browser not started");
+		await this.page.context().tracing.stop({ path: outputPath });
+	}
 }

package/harness/e2e/test-engine.ts

@@ -18,19 +18,15 @@ import type {
 	E2EStep,
 	E2EResult,
 	E2EReport,
-} from "../../packages/types/src/runtime-types.ts";
-import { writeJson, appendJsonl } from "../../cli.ts";
-// @ts-expect-error - Bun has built-in Node.js types
+} from "../../packages/types/src/runtime-types.js";
+import { writeJson, appendJsonl } from "../../cli.js";
 import { join } from "node:path";
 
-export interface PlaywrightRunner {
-	navigate(url: string): Promise<void>;
-	click(selector: string): Promise<void>;
-	type(selector: string, text: string): Promise<void>;
-	wait(selector: string, timeout?: number): Promise<void>;
-	screenshot(path: string): Promise<void>;
-	assert(condition: string, message?: string): Promise<boolean>;
-}
+// Re-export from playwright-runner for backwards compatibility
+export type { E2ERunner as PlaywrightRunner } from "./playwright-runner.js";
+
+// Also import locally for use in this file
+import type { E2ERunner } from "./playwright-runner.js";
 
 export interface E2EConfig {
 	baseUrl: string;
@@ -44,7 +40,7 @@ export interface E2EConfig {
 export class E2ETestEngine {
 	private readonly rootDir: string;
 	private readonly config: E2EConfig;
-	private runner: PlaywrightRunner | null = null;
+	private runner: E2ERunner | null = null;
 
 	constructor(rootDir: string, config: E2EConfig) {
 		this.rootDir = rootDir;
@@ -61,7 +57,7 @@ export class E2ETestEngine {
 	/**
 	 * Set the Playwright runner
 	 */
-	setRunner(runner: PlaywrightRunner): void {
+	setRunner(runner: E2ERunner): void {
 		this.runner = runner;
 	}