pi-harness-runtime 0.10.7 → 0.10.11

package/packages/experience-replay/src/replay.ts

@@ -1,348 +0,0 @@
-/**
- * Experience Replay (RFC-0059)
- *
- * Reconstructs prior runtime execution from persisted events and checkpoints.
- */
-
-import type {
-	ReplayRequest,
-	ReplayResult,
-	ReplayEvent,
-	ReplayDivergence,
-	JobStateSnapshot,
-	ReplaySources,
-	DivergenceReason,
-	ReplayRuntimeEvent,
-	RuntimeEvent,
-	RuntimeCheckpoint,
-	TaskGraph,
-} from "./types.js";
-
-// --- Event Timeline Reconstruction -------------------------------------------
-
-function reconstructTimeline(
-	events: RuntimeEvent[],
-	startSequence = 0,
-): ReplayEvent[] {
-	return events.map((event, index) => ({
-		sequence: startSequence + index,
-		timestamp: event.ts,
-		type: event.type,
-		data: event.data || {},
-	}));
-}
-
-// --- State Reconstruction -----------------------------------------------------
-
-function reconstructState(
-	jobId: string,
-	checkpoint: RuntimeCheckpoint | undefined,
-	events: RuntimeEvent[],
-	taskGraph: TaskGraph | undefined,
-): JobStateSnapshot {
-	// Apply events to checkpoint to get final state
-	let currentTaskId = checkpoint?.currentTaskId;
-	let status = checkpoint?.status || "unknown";
-
-	// Process events to find latest state
-	for (const event of events) {
-		if (event.type === "task.started" && event.data?.taskId) {
-			currentTaskId = event.data.taskId as string;
-		}
-		if (event.type === "job.status") {
-			status = (event.data?.status as string) || status;
-		}
-	}
-
-	return {
-		jobId,
-		status,
-		currentTaskId,
-		checkpoint: checkpoint || {
-			version: 0,
-			jobId,
-			status: "unknown",
-			requirement: "",
-			createdAt: new Date().toISOString(),
-			updatedAt: new Date().toISOString(),
-		},
-		taskGraph: taskGraph || { nodes: [], edges: [] },
-		events,
-		timestamp: new Date().toISOString(),
-	};
-}
-
-// --- Divergence Detection ----------------------------------------------------
-
-// --- Source Validation --------------------------------------------------------
-
-function validateSources(sources: ReplaySources): {
-	valid: boolean;
-	missing: string[];
-} {
-	const missing: string[] = [];
-
-	if (!sources.checkpoint && !sources.events) {
-		missing.push("checkpoint or events");
-	}
-
-	return { valid: missing.length === 0, missing };
-}
-
-// --- Mode Handlers ------------------------------------------------------------
-
-async function handleInspect(
-	sources: ReplaySources,
-	jobId: string,
-	fromSequence?: number,
-	toSequence?: number,
-): Promise<{ state: JobStateSnapshot; timeline: ReplayEvent[] }> {
-	const events = sources.events || [];
-	const filteredEvents =
-		fromSequence !== undefined || toSequence !== undefined
-			? events.slice(fromSequence, toSequence)
-			: events;
-
-	const timeline = reconstructTimeline(filteredEvents, fromSequence ?? 0);
-	const state = reconstructState(
-		jobId,
-		sources.checkpoint,
-		filteredEvents,
-		sources.taskGraph,
-	);
-
-	return { state, timeline };
-}
-
-async function handleSimulate(
-	sources: ReplaySources,
-	jobId: string,
-	fromSequence?: number,
-	toSequence?: number,
-): Promise<{
-	state: JobStateSnapshot;
-	timeline: ReplayEvent[];
-	divergences: ReplayDivergence[];
-}> {
-	const events = sources.events || [];
-	const filteredEvents =
-		fromSequence !== undefined || toSequence !== undefined
-			? events.slice(fromSequence, toSequence)
-			: events;
-
-	const timeline = reconstructTimeline(filteredEvents, fromSequence ?? 0);
-	const state = reconstructState(
-		jobId,
-		sources.checkpoint,
-		filteredEvents,
-		sources.taskGraph,
-	);
-
-	// Check for divergent events
-	const divergences: ReplayDivergence[] = [];
-	for (let i = 0; i < timeline.length; i++) {
-		const event = timeline[i];
-		if (event.type.includes("error") || event.type.includes("failure")) {
-			divergences.push({
-				sequence: event.sequence,
-				reason: "Provider output differs" as DivergenceReason,
-				severity: "warning",
-			});
-		}
-	}
-
-	return { state, timeline, divergences };
-}
-
-async function handleReexecute(
-	sources: ReplaySources,
-	jobId: string,
-	allowExternalCalls: boolean,
-): Promise<{
-	state: JobStateSnapshot;
-	timeline: ReplayEvent[];
-	divergences: ReplayDivergence[];
-}> {
-	// Reexecute requires explicit approval and valid sources
-	const validation = validateSources(sources);
-	if (!validation.valid) {
-		throw new Error(
-			`Missing required sources: ${validation.missing.join(", ")}`,
-		);
-	}
-
-	if (!allowExternalCalls) {
-		throw new Error(
-			"Reexecution with external calls requires explicit approval",
-		);
-	}
-
-	// For reexecution, we simulate first then mark for actual reexecution
-	const result = await handleSimulate(sources, jobId);
-
-	// Add informational divergence for reexecution mode
-	result.divergences.push({
-		sequence: 0,
-		reason: "Runtime version differs" as DivergenceReason,
-		severity: "info",
-	});
-
-	return result;
-}
-
-// --- Main Engine ---------------------------------------------------------------
-
-export class ExperienceReplay {
-	private eventListeners: Array<(event: ReplayRuntimeEvent) => void> = [];
-
-	/**
-	 * Replay a prior job execution
-	 */
-	async replay(
-		request: ReplayRequest,
-		sources: ReplaySources,
-	): Promise<ReplayResult> {
-		const { jobId, mode } = request;
-
-		// Emit start event
-		this.emit({ type: "replay.started", jobId, mode });
-
-		// Validate sources
-		const validation = validateSources(sources);
-		if (!validation.valid) {
-			return {
-				jobId,
-				reconstructedState: {
-					jobId,
-					status: "error",
-					checkpoint: sources.checkpoint || ({} as RuntimeCheckpoint),
-					taskGraph: sources.taskGraph || { nodes: [], edges: [] },
-					events: [],
-					timestamp: new Date().toISOString(),
-				},
-				timeline: [],
-				divergences: [
-					{
-						sequence: 0,
-						reason: `Missing sources: ${validation.missing.join(", ")}`,
-						severity: "error",
-					},
-				],
-				artifacts: [],
-				replayedAt: new Date().toISOString(),
-			};
-		}
-
-		try {
-			let result: {
-				state: JobStateSnapshot;
-				timeline: ReplayEvent[];
-				divergences?: ReplayDivergence[];
-			};
-
-			switch (mode) {
-				case "inspect":
-					result = await handleInspect(
-						sources,
-						jobId,
-						request.fromSequence,
-						request.toSequence,
-					);
-					break;
-				case "simulate":
-					result = await handleSimulate(
-						sources,
-						jobId,
-						request.fromSequence,
-						request.toSequence,
-					);
-					break;
-				case "reexecute":
-					result = await handleReexecute(
-						sources,
-						jobId,
-						request.allowExternalCalls,
-					);
-					break;
-			}
-
-			// Emit divergence events
-			if (result.divergences) {
-				for (const div of result.divergences) {
-					this.emit({
-						type: "replay.divergence.detected",
-						jobId,
-						reason: div.reason,
-					});
-				}
-			}
-
-			// Collect artifacts
-			const artifacts: string[] = [];
-			if (sources.prompts) artifacts.push(...Object.keys(sources.prompts));
-			if (sources.outputs) artifacts.push(...Object.keys(sources.outputs));
-
-			// Emit completion event
-			this.emit({ type: "replay.completed", jobId });
-
-			return {
-				jobId,
-				reconstructedState: result.state,
-				timeline: result.timeline,
-				divergences: result.divergences || [],
-				artifacts,
-				replayedAt: new Date().toISOString(),
-			};
-		} catch (error) {
-			const errorMessage =
-				error instanceof Error ? error.message : String(error);
-			return {
-				jobId,
-				reconstructedState: {
-					jobId,
-					status: "error",
-					checkpoint: sources.checkpoint || ({} as RuntimeCheckpoint),
-					taskGraph: sources.taskGraph || { nodes: [], edges: [] },
-					events: [],
-					timestamp: new Date().toISOString(),
-				},
-				timeline: [],
-				divergences: [
-					{
-						sequence: 0,
-						reason: errorMessage,
-						severity: "error",
-					},
-				],
-				artifacts: [],
-				replayedAt: new Date().toISOString(),
-			};
-		}
-	}
-
-	/**
-	 * Subscribe to replay events
-	 */
-	onEvent(listener: (event: ReplayRuntimeEvent) => void): () => void {
-		this.eventListeners.push(listener);
-		return () => {
-			this.eventListeners = this.eventListeners.filter((l) => l !== listener);
-		};
-	}
-
-	private emit(event: ReplayRuntimeEvent): void {
-		for (const listener of this.eventListeners) {
-			try {
-				listener(event);
-			} catch {
-				// Best effort
-			}
-		}
-	}
-}
-
-// --- Factory -----------------------------------------------------------------
-
-export function createExperienceReplay(): ExperienceReplay {
-	return new ExperienceReplay();
-}

package/packages/experience-replay/src/types.ts

@@ -1,128 +0,0 @@
-/**
- * Experience Replay Types (RFC-0059)
- *
- * Interfaces for replaying prior runtime execution.
- */
-
-// --- Local Type Definitions -----------------------------------------------
-
-export interface RuntimeEvent {
-	ts: string;
-	jobId: string;
-	type: string;
-	message: string;
-	data?: Record<string, unknown>;
-}
-
-export interface RuntimeCheckpoint {
-	version: number;
-	jobId: string;
-	status: string;
-	requirement: string;
-	currentTaskId?: string;
-	provider?: string;
-	resumeAt?: string;
-	lastError?: string;
-	createdAt: string;
-	updatedAt: string;
-}
-
-export interface TaskGraphNode {
-	id: string;
-	title: string;
-	description: string;
-	status: string;
-	dependencies: string[];
-}
-
-export interface TaskGraph {
-	nodes: TaskGraphNode[];
-	edges: Array<{ from: string; to: string }>;
-}
-
-// --- Replay Types -------------------------------------------------------------
-
-export type ReplayMode = "inspect" | "simulate" | "reexecute";
-
-export interface ReplayRequest {
-	jobId: string;
-	mode: ReplayMode;
-	fromSequence?: number;
-	toSequence?: number;
-	allowExternalCalls: boolean;
-}
-
-export interface JobStateSnapshot {
-	jobId: string;
-	status: string;
-	currentTaskId?: string;
-	checkpoint: RuntimeCheckpoint;
-	taskGraph: TaskGraph;
-	events: RuntimeEvent[];
-	timestamp: string;
-}
-
-export interface ReplayEvent {
-	sequence: number;
-	timestamp: string;
-	type: string;
-	data: Record<string, unknown>;
-}
-
-export interface ReplayDivergence {
-	sequence: number;
-	reason: string;
-	expected?: unknown;
-	actual?: unknown;
-	severity: "info" | "warning" | "error";
-}
-
-export interface ReplayResult {
-	jobId: string;
-	reconstructedState: JobStateSnapshot;
-	timeline: ReplayEvent[];
-	divergences: ReplayDivergence[];
-	artifacts: string[];
-	replayedAt: string;
-}
-
-// --- Replay Sources -----------------------------------------------------------
-
-export interface ReplaySources {
-	checkpoint?: RuntimeCheckpoint;
-	events?: RuntimeEvent[];
-	taskGraph?: TaskGraph;
-	prompts?: Record<string, string>;
-	outputs?: Record<string, string>;
-	testResults?: Record<string, unknown>;
-	evaluation?: Record<string, unknown>;
-	repairs?: Record<string, unknown>;
-	knowledgeRefs?: string[];
-	/** Filter events by sequence range */
-	fromSequence?: number;
-	toSequence?: number;
-}
-
-// --- Divergence Detection -----------------------------------------------------
-
-export type DivergenceReason =
-	| "source_file_changed"
-	| "project_rules_changed"
-	| "provider_output_differs"
-	| "test_environment_changed"
-	| "required_artifact_missing"
-	| "runtime_version_differs";
-
-export interface DivergenceCheck {
-	type: DivergenceReason;
-	check: () => Promise<boolean>;
-	severity: "info" | "warning" | "error";
-}
-
-// --- Runtime Events -----------------------------------------------------------
-
-export type ReplayRuntimeEvent =
-	| { type: "replay.started"; jobId: string; mode: ReplayMode }
-	| { type: "replay.state.reconstructed"; jobId: string; sequence: number }
-	| { type: "replay.divergence.detected"; jobId: string; reason: string }
-	| { type: "replay.completed"; jobId: string };