pi-harness-runtime 0.10.11 → 0.10.12

package/harness/auto-compact.ts

@@ -0,0 +1,309 @@
+/**
+ * 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.
+ *
+ * This module integrates with:
+ * - `continue-prompt.ts` for prompt generation
+ * - `context-compact-orchestrator.ts` for compact decisions
+ * - `partial-recovery.ts` for artifact persistence
+ *
+ * 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";
+import {
+	continuePromptGenerator,
+	type ContinueContext,
+} from "./continue-prompt.js";
+
+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;
+	requirement?: 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,
+	/\[Earlier conversation summarized\]/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,
+	/do not repeat work already completed/i,
+];
+
+export class AutoCompactEngine {
+	private readonly rootDir: string;
+	private readonly jobId: string;
+	private readonly requirement: string;
+	private readonly maxAttempts: number;
+	private continueAttempts = 0;
+
+	constructor(config: CompactionConfig) {
+		this.rootDir =
+			config.rootDir ??
+			join(homedir(), ".pi", "harness", config.jobId, "context");
+		this.jobId = config.jobId;
+		this.requirement = config.requirement ?? "";
+		this.maxAttempts = config.maxContinueAttempts ?? 5;
+	}
+
+	/**
+	 * 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 {
+		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";
+		} else if (/\[Earlier conversation summarized\]/i.test(output)) {
+			reason = "context_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 using ContinuePromptGenerator
+	 */
+	generateContinuePrompt(
+		taskId: string,
+		completedWork: string[],
+		remainingWork: string[],
+	): string {
+		const context: ContinueContext = {
+			taskId,
+			requirement: this.requirement || "Continue from previous session",
+			whatWasCompleted: completedWork,
+			whatNeedsToBeDone: remainingWork,
+			partialFiles: this.findPartialFiles(),
+			decisions: [],
+		};
+
+		const prompt = continuePromptGenerator.generate(context);
+
+		// Also save to file for persistence
+		const promptPath = join(this.rootDir, "continue_prompt.md");
+		writeFileSync(promptPath, prompt, "utf-8");
+
+		return prompt;
+	}
+
+	/**
+	 * Generate minimal continue prompt
+	 */
+	generateMinimalContinuePrompt(
+		summary: string,
+		recentContent: string,
+	): string {
+		return [
+			"Continue from where you left off.",
+			"",
+			"## Summary",
+			summary,
+			"",
+			"## Recent Context",
+			recentContent.substring(0, 2000),
+			"",
+			"**Do not repeat work already completed.** Focus on completing the remaining work.",
+		].join("\n");
+	}
+
+	/**
+	 * 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";
+	}
+
+	/**
+	 * Load continue prompt from file
+	 */
+	loadContinuePrompt(): string | null {
+		const promptPath = join(this.rootDir, "continue_prompt.md");
+		if (existsSync(promptPath)) {
+			return readFileSync(promptPath, "utf-8");
+		}
+		return null;
+	}
+
+	/**
+	 * Check if there's a pending continue prompt
+	 */
+	hasContinuePrompt(): boolean {
+		return existsSync(join(this.rootDir, "continue_prompt.md"));
+	}
+
+	// --- 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 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/auto-quota-resume.ts

@@ -0,0 +1,132 @@
+/**
+ * Auto Quota Resume — schedules automatic job resume when quota resets.
+ *
+ * Flow:
+ *   quota exhaustion detected
+ *     → read h5_resets_at_epoch from mirror
+ *     → compute resumeAt ISO timestamp
+ *     → call machine.setResumeTime(resumeAt)
+ *     → schedule setTimeout for auto-resume
+ *     → at timeout: machine.transition("running")
+ *
+ * Only the 5h window is auto-resumed (provider-reported, predictable).
+ * Weekly/monthly quota exhaustion requires human monitoring.
+ */
+
+import type { MirrorStore } from "../mirror.js";
+import type { JobStateMachine } from "./job-state-machine.js";
+
+/** Small buffer (ms) before the exact reset time to resume. */
+const RESUME_BUFFER_MS = 10_000; // 10 seconds — resume just before reset
+
+/** Minimum time to wait before auto-resuming (avoid immediate re-trigger). */
+const MIN_RESUME_DELAY_MS = 5_000; // 5 seconds
+
+/** Map of jobId → active auto-resume timer handle. */
+const activeTimers = new Map<
+	string,
+	{ timeout: ReturnType<typeof setTimeout>; resumeAt: number }
+>();
+
+/**
+ * Schedule an auto-resume for a job that was paused due to quota exhaustion.
+ *
+ * Reads the reset epoch from the mirror store for the given provider,
+ * computes the resume time, sets it on the checkpoint, and schedules
+ * a setTimeout to transition back to "running".
+ *
+ * Returns the scheduled resumeAt ISO string, or null if no epoch data
+ * is available (requires human resume).
+ */
+export function scheduleAutoResume(
+	provider: string,
+	machine: JobStateMachine,
+	mirrorStore: MirrorStore,
+): string | null {
+	const jobId = machine.getCheckpoint()?.jobId;
+	if (!jobId) return null;
+
+	// Cancel any existing timer for this job
+	cancelAutoResume(jobId);
+
+	const mirror = mirrorStore.readAll();
+	const record = mirror?.[provider];
+	if (!record) return null;
+
+	// Only auto-resume on 5h quota exhaustion (has precise epoch)
+	if (typeof record.h5_resets_at_epoch !== "number") return null;
+
+	const resetEpoch = record.h5_resets_at_epoch;
+	const now = Date.now();
+	const delayMs = Math.max(
+		resetEpoch - now - RESUME_BUFFER_MS,
+		MIN_RESUME_DELAY_MS,
+	);
+	const resumeAt = now + delayMs;
+	const resumeAtIso = new Date(resumeAt).toISOString();
+
+	// Persist to checkpoint so resumeAt survives worker restart
+	machine.setResumeTime(resumeAtIso);
+
+	// console.log(
+	// 	`[auto-quota-resume] ${provider} 5h quota exhausted.` +
+	// 		` Auto-resume scheduled at ${resumeAtIso} (in ${Math.round(delayMs / 1000)}s)`,
+	// );
+
+	const timeout = setTimeout(async () => {
+		activeTimers.delete(jobId);
+
+		const checkpoint = machine.getCheckpoint();
+		if (!checkpoint || checkpoint.status !== "paused_quota") {
+			// Job was manually resumed or cancelled
+			return;
+		}
+
+		// Check the mirror — if quota is still exhausted, shift the timer
+		const updated = mirrorStore.readAll()?.[provider];
+		if (updated?.h5_resets_at_epoch) {
+			const stillExhausted = Date.now() < updated.h5_resets_at_epoch;
+			if (stillExhausted) {
+				// console.log(
+				// 	`[auto-quota-resume] ${provider} still exhausted at scheduled time.` +
+				// 			` Re-scheduling...`,
+				// );
+				scheduleAutoResume(provider, machine, mirrorStore);
+				return;
+			}
+		}
+
+		const result = await machine.transition("running");
+		if (result.success) {
+			// console.log(
+			// 	`[auto-quota-resume] Job ${jobId} auto-resumed after ${provider} 5h quota reset.`,
+			// );
+		} else {
+			console.error(
+				`[auto-quota-resume] Auto-resume failed for ${jobId}: ${result.error}`,
+			);
+		}
+	}, delayMs);
+
+	activeTimers.set(jobId, { timeout, resumeAt });
+	return resumeAtIso;
+}
+
+/**
+ * Cancel the auto-resume timer for a job.
+ * Call this when the job is manually resumed or cancelled.
+ */
+export function cancelAutoResume(jobId: string): void {
+	const existing = activeTimers.get(jobId);
+	if (existing) {
+		clearTimeout(existing.timeout);
+		activeTimers.delete(jobId);
+	}
+}
+
+/**
+ * Get the scheduled resume time for a job, or null if not scheduled.
+ */
+export function getScheduledResume(jobId: string): number | null {
+	return activeTimers.get(jobId)?.resumeAt ?? null;
+}

package/harness/autonomous-review.ts

@@ -0,0 +1,88 @@
+/**
+ * Autonomous Review Agent — polls for code.written events and auto-triggers review.
+ * Human on the loop, not in the loop.
+ */
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import {
+	createHerdrBus,
+	ensureHerdrWorkspace,
+	publishReviewCompletedSimple,
+	publishReviewRequestedSimple,
+} from "../packages/event-bus/src/herdr-bus.js";
+
+const AGENT_ID = "review-agent";
+const REVIEW_TIMEOUT_MS = 5 * 60 * 1000;
+
+type CodeWrittenPayload = { taskId: string; files: string[]; branch?: string };
+
+async function runReview(
+	bus: ReturnType<typeof createHerdrBus>,
+	codePayload: CodeWrittenPayload,
+): Promise<void> {
+	const { taskId, files } = codePayload;
+	const reportFile = join(
+		ensureHerdrWorkspace().reviews,
+		`${taskId}-review.md`,
+	);
+	console.log(`[${AGENT_ID}] Reviewing task ${taskId}, ${files.length} files`);
+
+	try {
+		publishReviewRequestedSimple(bus, taskId, taskId);
+
+		const fileBlocks = await Promise.all(
+			files.map(async (file) => {
+				const content = existsSync(file)
+					? readFileSync(file, "utf-8").slice(0, 5000)
+					: `[Not found: ${file}]`;
+				return `## ${file}\n\n\`\`\`\n${content}\n\`\`\`\n`;
+			}),
+		);
+
+		const report = `# Code Review — Task ${taskId}
+## Files: ${files.join(", ")}
+
+> Auto-generated. GPT review tab fills this in.
+
+${fileBlocks.join("\n")}
+`;
+		writeFileSync(reportFile, report);
+		console.log(`[${AGENT_ID}] Report: ${reportFile}`);
+		publishReviewCompletedSimple(bus, taskId, reportFile, "changes_requested");
+
+		// Wait for GPT tab to update
+		await waitForGptReview(reportFile);
+	} catch (err) {
+		console.error(`[${AGENT_ID}] Review failed:`, err);
+		publishReviewCompletedSimple(bus, taskId, reportFile, "failed");
+	}
+}
+
+async function waitForGptReview(reportFile: string): Promise<void> {
+	const deadline = Date.now() + REVIEW_TIMEOUT_MS;
+	while (Date.now() < deadline) {
+		if (existsSync(reportFile)) {
+			const content = readFileSync(reportFile, "utf-8");
+			if (!content.includes("Pending")) return;
+		}
+		await new Promise((r) => setTimeout(r, 5000));
+	}
+	console.log(`[${AGENT_ID}] GPT review timed out`);
+}
+
+async function main(): Promise<void> {
+	console.log(`[${AGENT_ID}] Starting...`);
+	const bus = createHerdrBus(AGENT_ID);
+	ensureHerdrWorkspace();
+	bus.subscribe("code.written");
+	bus.startPolling(async (payload) => {
+		if (payload.topic === "code.written") {
+			const data = payload.data as CodeWrittenPayload;
+			if (data.files?.length) runReview(bus, data).catch(console.error);
+		}
+	});
+	console.log(`[${AGENT_ID}] Workspace: ${bus.getWorkspace()}`);
+	console.log(`[${AGENT_ID}] Polling for code.written...`);
+}
+
+main().catch(console.error);