pi-harness-runtime 0.10.6 → 0.10.11

package/harness/agent-handoff.ts

@@ -1,189 +0,0 @@
-/**
- * Agent Handoff Protocol — RFC-0012
- *
- * Clean handoff between agents with context transfer.
- * Ensures continuity when switching agents mid-task.
- */
-
-import type {
-	HandoffContext,
-	HandoffEvent,
-} from "../packages/types/src/runtime-types.ts";
-import { writeJson, readJson } from "../cli.ts";
-// @ts-expect-error - Bun has built-in Node.js types
-import { join } from "node:path";
-
-export interface HandoffData {
-	fromAgent: string;
-	toAgent: string;
-	taskId: string;
-	taskSummary: string;
-	contextFiles: string[];
-	recentHistory: string[];
-	currentState: Record<string, unknown>;
-}
-
-export class AgentHandoffProtocol {
-	private readonly rootDir: string;
-
-	constructor(rootDir: string) {
-		this.rootDir = rootDir;
-	}
-
-	/**
-	 * Create a handoff context for switching agents
-	 */
-	createHandoff(
-		jobId: string,
-		taskId: string,
-		fromAgent: string,
-		toAgent: string,
-		currentState?: Record<string, unknown>,
-	): HandoffContext {
-		const events = this.loadHandoffHistory(jobId, taskId);
-
-		return {
-			jobId,
-			taskId,
-			fromAgent,
-			toAgent,
-			sharedFiles: [],
-			taskHistory: events,
-			summary: this.generateSummary(taskId, currentState),
-		};
-	}
-
-	/**
-	 * Record a handoff event
-	 */
-	recordHandoff(context: HandoffContext, result?: string): void {
-		const path = join(
-			this.rootDir,
-			"jobs",
-			context.jobId,
-			"handoffs",
-			`${context.taskId}.json`,
-		);
-		const event: HandoffEvent = {
-			ts: new Date().toISOString(),
-			agentId: context.toAgent,
-			action: "handoff_received",
-			result,
-		};
-		context.taskHistory.push(event);
-		writeJson(path, context);
-	}
-
-	/**
-	 * Generate handoff prompt for the receiving agent
-	 */
-	generateHandoffPrompt(context: HandoffContext): string {
-		const lines = [
-			`## Agent Handoff`,
-			``,
-			`**From Agent:** ${context.fromAgent}`,
-			`**To Agent:** ${context.toAgent}`,
-			`**Task:** ${context.taskId}`,
-			``,
-			`### Task History`,
-		];
-
-		for (const event of context.taskHistory) {
-			lines.push(`- [${event.ts}] ${event.agentId}: ${event.action}`);
-			if (event.result) {
-				lines.push(`  Result: ${event.result}`);
-			}
-		}
-
-		lines.push(``);
-		lines.push(`### Summary`);
-		lines.push(context.summary);
-
-		if (context.sharedFiles.length > 0) {
-			lines.push(``);
-			lines.push(`### Shared Files`);
-			for (const file of context.sharedFiles) {
-				lines.push(`- ${file}`);
-			}
-		}
-
-		return lines.join("\n");
-	}
-
-	/**
-	 * Validate handoff readiness
-	 */
-	validateHandoff(context: HandoffContext): {
-		valid: boolean;
-		issues: string[];
-	} {
-		const issues: string[] = [];
-
-		if (!context.summary) {
-			issues.push("Task summary is empty");
-		}
-
-		if (context.taskHistory.length === 0) {
-			issues.push("No task history recorded");
-		}
-
-		// Check for recent handoffs
-		const recentHandoffs = context.taskHistory.filter((h) => {
-			const age = Date.now() - Date.parse(h.ts);
-			return age < 5 * 60 * 1000; // 5 minutes
-		});
-
-		if (recentHandoffs.length > 3) {
-			issues.push(
-				`Too many recent handoffs (${recentHandoffs.length}). Possible ping-pong.`,
-			);
-		}
-
-		return { valid: issues.length === 0, issues };
-	}
-
-	/**
-	 * Load handoff history for a task
-	 */
-	private loadHandoffHistory(jobId: string, taskId: string): HandoffEvent[] {
-		const path = join(
-			this.rootDir,
-			"jobs",
-			jobId,
-			"handoffs",
-			`${taskId}.json`,
-		);
-		const data = readJson(path) as HandoffContext | null;
-		return data?.taskHistory ?? [];
-	}
-
-	/**
-	 * Generate a summary of the task state
-	 */
-	private generateSummary(
-		taskId: string,
-		currentState?: Record<string, unknown>,
-	): string {
-		if (!currentState) {
-			return `Task ${taskId} requires continuation. Check task files for current state.`;
-		}
-
-		const lines = [`Task ${taskId} is in progress.`];
-
-		if (currentState.filesModified) {
-			lines.push(
-				`Files modified: ${(currentState.filesModified as string[]).join(", ")}`,
-			);
-		}
-
-		if (currentState.lastAction) {
-			lines.push(`Last action: ${currentState.lastAction}`);
-		}
-
-		if (currentState.blockers) {
-			lines.push(`Blockers: ${currentState.blockers}`);
-		}
-
-		return lines.join("\n");
-	}
-}

package/harness/auto-compact.ts

@@ -1,309 +0,0 @@
-/**
- * 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

@@ -1,132 +0,0 @@
-/**
- * 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

@@ -1,88 +0,0 @@
-/**
- * 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);