pi-crew 0.9.68 → 0.10.2

package/src/runtime/recovery/retry-runner.ts

@@ -1,330 +0,0 @@
-/**
- * RetryRunner - Execute tasks with retry support and summary accumulation.
- *
- * Based on pi-boomerang's --rethrow pattern:
- * - Retries failed tasks up to maxAttempts
- * - Generates handoffs between attempts
- * - Accumulates context from previous attempts
- * - Supports exponential backoff
- * - Limits handoff accumulation to prevent memory leaks
- */
-
-import type { HandoffManager, HandoffSummary, TaskPacket, TaskResult } from "../handoff-manager.ts";
-
-/**
- * Retry configuration.
- */
-export interface RetryConfig {
-	/** Maximum number of retry attempts */
-	maxAttempts: number;
-	/** Generate summary between attempts for context accumulation */
-	summaryBetweenAttempts?: boolean;
-	/** Stop retrying if task succeeds */
-	stopOnSuccess?: boolean;
-	/** Base backoff delay in milliseconds (multiplied by attempt number) */
-	backoffMs?: number;
-	/** Backoff multiplier (default: 1) */
-	backoffMultiplier?: number;
-	/** Maximum backoff delay cap in milliseconds */
-	maxBackoffMs?: number;
-	/** Custom retry condition (return true to retry) */
-	retryCondition?: (result: TaskResult, attempt: number) => boolean;
-	/** Maximum handoffs to retain (default: 100) - prevents memory leaks */
-	maxHandoffs?: number;
-}
-
-/**
- * Result of a single attempt.
- */
-export interface AttemptResult {
-	attempt: number;
-	result: TaskResult;
-	summary?: HandoffSummary;
-	duration: number;
-	error?: string;
-	timestamp: number;
-}
-
-/**
- * Final retry result.
- */
-export interface RetryResult {
-	success: boolean;
-	attempts: AttemptResult[];
-	finalResult?: TaskResult;
-	totalHandoffs: HandoffSummary[];
-	totalDuration: number;
-}
-
-/**
- * Task runner interface (minimal for retry functionality).
- */
-export interface TaskRunnerLike {
-	runTask(packet: TaskPacket): Promise<TaskResult>;
-}
-
-/**
- * RetryRunner handles task execution with automatic retry and summary accumulation.
- */
-export class RetryRunner {
-	private _disposed = false;
-
-	private taskRunner: TaskRunnerLike;
-	private handoffManager: HandoffManager;
-
-	constructor(taskRunner: TaskRunnerLike, handoffManager: HandoffManager) {
-		this.taskRunner = taskRunner;
-		this.handoffManager = handoffManager;
-	}
-
-	/**
-	 * Check if this runner has been disposed.
-	 */
-	get isDisposed(): boolean {
-		return this._disposed;
-	}
-
-	/**
-	 * Dispose of resources held by this runner.
-	 * Clears any accumulated state and prevents further operations.
-	 */
-	dispose(): void {
-		this._disposed = true;
-	}
-
-	/**
-	 * Clear accumulated handoffs to free memory.
-	 * Useful when you want to reset state without disposing.
-	 */
-	clearHandoffs(): void {
-		/* no-op: _handoffs field removed (was never read) */
-	}
-
-	/**
-	 * Get the effective max handoffs limit from config or default.
-	 */
-	private getMaxHandoffs(config: RetryConfig): number {
-		return config.maxHandoffs ?? 100;
-	}
-
-	/**
-	 * Trim handoffs array to max size, keeping most recent.
-	 */
-	private trimHandoffs(handoffs: HandoffSummary[], maxSize: number): HandoffSummary[] {
-		if (handoffs.length <= maxSize) {
-			return handoffs;
-		}
-		// Keep the most recent handoffs (last maxSize items)
-		return handoffs.slice(-maxSize);
-	}
-
-	/**
-	 * Execute task with retry support.
-	 * Summaries accumulate between attempts for better context.
-	 *
-	 * @param packet - Task packet to execute
-	 * @param config - Retry configuration (stopOnSuccess defaults to true)
-	 * @returns Final retry result with all attempts
-	 */
-	async runWithRetry(packet: TaskPacket, config: RetryConfig): Promise<RetryResult> {
-		if (this._disposed) {
-			throw new Error("RetryRunner has been disposed");
-		}
-
-		const attempts: AttemptResult[] = [];
-		const handoffs: HandoffSummary[] = [];
-		const startTime = Date.now();
-		const maxHandoffs = this.getMaxHandoffs(config);
-
-		for (let attempt = 1; attempt <= config.maxAttempts; attempt++) {
-			if (this._disposed) {
-				throw new Error("RetryRunner was disposed during retry");
-			}
-			const attemptStart = Date.now();
-
-			try {
-				// Inject accumulated handoffs into context
-				const enrichedPacket = this.enrichPacketWithHandoffs(packet, handoffs, attempt);
-
-				// Execute task
-				const result = await this.taskRunner.runTask(enrichedPacket);
-
-				const attemptResult: AttemptResult = {
-					attempt,
-					result,
-					duration: Date.now() - attemptStart,
-					timestamp: Date.now(),
-				};
-
-				// Generate summary between attempts
-				if (config.summaryBetweenAttempts !== false) {
-					const summary = await this.handoffManager.generateSummary(packet, result);
-					attemptResult.summary = summary;
-					handoffs.push(summary);
-
-					// Trim handoffs to prevent memory leak
-					if (handoffs.length > maxHandoffs) {
-						handoffs.splice(0, handoffs.length - maxHandoffs);
-					}
-				}
-
-				attempts.push(attemptResult);
-
-				// Stop on success if configured (default to true when undefined)
-				if ((config.stopOnSuccess ?? true) && result.outcome === "success") {
-					return {
-						success: true,
-						attempts,
-						finalResult: result,
-						totalHandoffs: handoffs,
-						totalDuration: Date.now() - startTime,
-					};
-				}
-
-				// Check custom retry condition
-				if (config.retryCondition && !config.retryCondition(result, attempt)) {
-					break;
-				}
-
-				// Check default retry condition (retry on failure)
-				if (result.outcome !== "success" && attempt < config.maxAttempts) {
-					// Apply backoff before retry
-					const backoffDelay = this.calculateBackoff(
-						config.backoffMs ?? 1000,
-						attempt,
-						config.backoffMultiplier ?? 1,
-						config.maxBackoffMs,
-					);
-					if (backoffDelay > 0) {
-						await this.sleep(backoffDelay);
-					}
-				}
-			} catch (error) {
-				attempts.push({
-					attempt,
-					result: {
-						outcome: "failure",
-						error: error instanceof Error ? error.message : String(error),
-					},
-					duration: Date.now() - attemptStart,
-					timestamp: Date.now(),
-					error: error instanceof Error ? error.message : String(error),
-				});
-
-				// Apply backoff before retry on error
-				if (config.backoffMs && attempt < config.maxAttempts) {
-					const backoffDelay = this.calculateBackoff(
-						config.backoffMs,
-						attempt,
-						config.backoffMultiplier ?? 1,
-						config.maxBackoffMs,
-					);
-					if (backoffDelay > 0) {
-						await this.sleep(backoffDelay);
-					}
-				}
-			}
-		}
-
-		const finalAttempt = attempts[attempts.length - 1];
-		return {
-			success: finalAttempt?.result.outcome === "success",
-			attempts,
-			finalResult: finalAttempt?.result,
-			totalHandoffs: this.trimHandoffs(handoffs, maxHandoffs),
-			totalDuration: Date.now() - startTime,
-		};
-	}
-
-	/**
-	 * Enrich packet with accumulated handoffs from previous attempts.
-	 */
-	private enrichPacketWithHandoffs(packet: TaskPacket, handoffs: HandoffSummary[], attempt: number): TaskPacket {
-		if (handoffs.length === 0) {
-			return packet;
-		}
-
-		// Build accumulated context from previous attempts
-		const accumulatedContext = handoffs
-			.map(
-				(h, index) =>
-					`## Attempt ${index + 1}: ${h.task}\n` +
-					`Outcome: ${h.outcome}\n` +
-					`Files: created=${h.filesCreated.join(", ")}, modified=${h.filesModified.join(", ")}\n` +
-					`Decisions: ${h.decisions.map((d) => d.rationale).join("; ")}\n` +
-					`Blockers: ${h.blockers.join(", ")}\n` +
-					`Next Steps: ${h.nextSteps.join(", ")}\n`,
-			)
-			.join("\n---\n");
-
-		return {
-			...packet,
-			context: {
-				...packet.context,
-				__boomerangAttempts: attempt,
-				__boomerangHandoffs: handoffs,
-				__boomerangContext: `Previous attempts summary:\n${accumulatedContext}`,
-			},
-		};
-	}
-
-	/**
-	 * Calculate backoff delay with optional capping.
-	 */
-	private calculateBackoff(baseMs: number, attempt: number, multiplier: number, maxBackoffMs?: number): number {
-		let delay = baseMs * multiplier ** (attempt - 1);
-		if (maxBackoffMs !== undefined) {
-			delay = Math.min(delay, maxBackoffMs);
-		}
-		return delay;
-	}
-
-	/**
-	 * Sleep helper.
-	 */
-	private sleep(ms: number): Promise<void> {
-		return new Promise((resolve) => setTimeout(resolve, ms));
-	}
-}
-
-/**
- * Create a RetryRunner with default dependencies.
- */
-export function createRetryRunner(taskRunner: TaskRunnerLike, handoffManager: HandoffManager): RetryRunner {
-	return new RetryRunner(taskRunner, handoffManager);
-}
-
-/**
- * Default retry config for common scenarios.
- */
-export const DEFAULT_RETRY_CONFIG: RetryConfig = {
-	maxAttempts: 3,
-	summaryBetweenAttempts: true,
-	stopOnSuccess: true,
-	backoffMs: 1000,
-	backoffMultiplier: 2,
-	maxBackoffMs: 30000,
-};
-
-/**
- * Retry config for transient failures (quick retries).
- */
-export const TRANSIENT_FAILURE_RETRY_CONFIG: RetryConfig = {
-	maxAttempts: 2,
-	summaryBetweenAttempts: false,
-	stopOnSuccess: true,
-	backoffMs: 500,
-	backoffMultiplier: 1,
-};
-
-/**
- * Retry config for persistent failures (exponential backoff).
- */
-export const PERSISTENT_FAILURE_RETRY_CONFIG: RetryConfig = {
-	maxAttempts: 5,
-	summaryBetweenAttempts: true,
-	stopOnSuccess: true,
-	backoffMs: 2000,
-	backoffMultiplier: 2,
-	maxBackoffMs: 60000,
-};

package/src/runtime/run-drift.ts

@@ -1,219 +0,0 @@
-/**
- * Runtime drift detectors — detect state anomalies in pi-crew runs.
- *
- * Pattern origin: GSD-2 ADR-017 drift detection & state reconciliation.
- * Each detector checks for a specific anomaly and returns a report.
- * Repair handlers are idempotent — safe to run multiple times.
- */
-
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import path from "node:path";
-import { logInternalError } from "../utils/internal-error.ts";
-
-// ── Types ────────────────────────────────────────────────────────────────
-
-export type DriftKind =
-	| "stale-process" // Heartbeat timeout (existing)
-	| "orphaned-claim" // Task claim without task
-	| "orphaned-worktree" // Worktree dir without active run
-	| "missing-timestamps" // State files without timestamps
-	| "status-divergence" // Manifest status ≠ status file
-	| "unregistered-run"; // State dir but no manifest
-
-export interface DriftReport {
-	kind: DriftKind;
-	runId: string;
-	details: string;
-	repaired: boolean;
-	repairResult?: string;
-}
-
-export interface DriftContext {
-	/** Root directory for crew state (.crew/) */
-	crewRoot: string;
-	/** Active run IDs (from registry) */
-	activeRunIds: Set<string>;
-	/** Manifest content if available */
-	manifest?: {
-		runId: string;
-		status: string;
-		cwd: string;
-		[k: string]: unknown;
-	};
-}
-
-// ── Detectors ────────────────────────────────────────────────────────────
-
-/**
- * Detect task claims that reference tasks not in the manifest.
- */
-export function detectOrphanedClaim(ctx: DriftContext): DriftReport | null {
-	if (!ctx.manifest) return null;
-	const claimsDir = path.join(ctx.crewRoot, "state", "task-claims");
-	if (!existsSync(claimsDir)) return null;
-
-	const claimFiles = readdirSync(claimsDir).filter((f) => f.endsWith(".json"));
-	for (const file of claimFiles) {
-		try {
-			const claim = JSON.parse(readFileSync(path.join(claimsDir, file), "utf-8"));
-			if (claim.runId === ctx.manifest.runId && claim.taskId) {
-				// Check if task exists in manifest tasks array
-				const tasks = (ctx.manifest as Record<string, unknown>).tasks;
-				if (Array.isArray(tasks) && !tasks.some((t: Record<string, unknown>) => t.id === claim.taskId)) {
-					return {
-						kind: "orphaned-claim",
-						runId: ctx.manifest.runId,
-						details: `Task claim '${claim.taskId}' references non-existent task`,
-						repaired: false,
-					};
-				}
-			}
-		} catch {
-			// Malformed claim file — skip
-		}
-	}
-	return null;
-}
-
-/**
- * Detect worktree directories that don't belong to any active run.
- */
-export function detectOrphanedWorktree(ctx: DriftContext): DriftReport | null {
-	const worktreesDir = path.join(ctx.crewRoot, "worktrees");
-	if (!existsSync(worktreesDir)) return null;
-
-	const dirs = readdirSync(worktreesDir, { withFileTypes: true })
-		.filter((d) => d.isDirectory())
-		.map((d) => d.name);
-
-	for (const dir of dirs) {
-		// Extract run ID from worktree dir name (format: <runId>-<taskId> or <runId>)
-		const runId = dir.split("-").slice(0, 5).join("-"); // heuristic: run IDs are timestamp-based
-		if (!ctx.activeRunIds.has(runId) && !ctx.activeRunIds.has(dir)) {
-			return {
-				kind: "orphaned-worktree",
-				runId: dir,
-				details: `Worktree '${dir}' has no active run`,
-				repaired: false,
-			};
-		}
-	}
-	return null;
-}
-
-/**
- * Detect state files missing required timestamps.
- */
-export function detectMissingTimestamps(ctx: DriftContext): DriftReport | null {
-	if (!ctx.manifest) return null;
-	const stateDir = path.join(ctx.crewRoot, "state");
-	if (!existsSync(stateDir)) return null;
-
-	// Check manifest has createdAt/updatedAt
-	const m = ctx.manifest as Record<string, unknown>;
-	if (!m.createdAt && !m.updatedAt) {
-		return {
-			kind: "missing-timestamps",
-			runId: ctx.manifest.runId,
-			details: "Manifest missing createdAt/updatedAt timestamps",
-			repaired: false,
-		};
-	}
-	return null;
-}
-
-/**
- * Detect divergence between manifest status and individual task status files.
- */
-export function detectStatusDivergence(ctx: DriftContext): DriftReport | null {
-	if (!ctx.manifest) return null;
-	const statusPath = path.join(ctx.crewRoot, "state", `${ctx.manifest.runId}.status`);
-	if (!existsSync(statusPath)) return null;
-
-	try {
-		const status = readFileSync(statusPath, "utf-8").trim();
-		if (status !== ctx.manifest.status) {
-			return {
-				kind: "status-divergence",
-				runId: ctx.manifest.runId,
-				details: `Manifest says '${ctx.manifest.status}' but status file says '${status}'`,
-				repaired: false,
-			};
-		}
-	} catch {
-		// Can't read status file — not drift, might be permissions
-	}
-	return null;
-}
-
-/**
- * Detect state directories that have no corresponding manifest.
- */
-export function detectUnregisteredRun(ctx: DriftContext): DriftReport | null {
-	const runsDir = path.join(ctx.crewRoot, "runs");
-	if (!existsSync(runsDir)) return null;
-
-	const runDirs = readdirSync(runsDir, { withFileTypes: true })
-		.filter((d) => d.isDirectory())
-		.map((d) => d.name);
-
-	for (const runId of runDirs) {
-		if (!ctx.activeRunIds.has(runId)) {
-			// Check if it has state files (manifest exists)
-			const manifestPath = path.join(runsDir, runId, "manifest.json");
-			if (existsSync(manifestPath)) {
-				try {
-					const stat = statSync(manifestPath);
-					const ageMs = Date.now() - stat.mtimeMs;
-					// Only flag if older than 1 hour (might be in-progress)
-					if (ageMs > 60 * 60 * 1000) {
-						return {
-							kind: "unregistered-run",
-							runId,
-							details: `Run '${runId}' has manifest but is not in active registry (age: ${Math.round(ageMs / 60000)}m)`,
-							repaired: false,
-						};
-					}
-				} catch {
-					// Can't stat — skip
-				}
-			}
-		}
-	}
-	return null;
-}
-
-// ── Reconciliation Loop ─────────────────────────────────────────────────
-
-const ALL_DETECTORS = [detectOrphanedClaim, detectOrphanedWorktree, detectMissingTimestamps, detectStatusDivergence, detectUnregisteredRun];
-
-/**
- * Run all drift detectors and collect reports.
- * Capped at maxPasses repair attempts.
- *
- * Pattern origin: GSD-2 ADR-017 — capped at 2 retry passes.
- */
-export function runDriftDetection(ctx: DriftContext, maxPasses = 2): DriftReport[] {
-	const reports: DriftReport[] = [];
-
-	for (let pass = 0; pass < maxPasses; pass++) {
-		let newFindings = 0;
-
-		for (const detector of ALL_DETECTORS) {
-			try {
-				const report = detector(ctx);
-				if (report) {
-					reports.push(report);
-					newFindings++;
-				}
-			} catch (error) {
-				logInternalError("run-drift", error, `detector=${detector.name} runId=${ctx.manifest?.runId}`);
-			}
-		}
-
-		// If no new findings, stop early
-		if (newFindings === 0) break;
-	}
-
-	return reports;
-}