pi-crew 0.9.51 → 0.9.53

package/src/runtime/anchor-manager.ts

@@ -1,475 +0,0 @@
-/**
- * Maximum number of anchors to prevent memory leaks.
- */
-const MAX_ANCHORS = 50;
-
-/**
- * Maximum number of handoffs per anchor to prevent memory leaks.
- */
-const MAX_HANDOFFS_PER_ANCHOR = 100;
-
-/**
- * AnchorManager - Creates shared summary points where multiple handoffs accumulate.
- *
- * Based on pi-boomerang's anchorMode pattern:
- * - setAnchor() creates a shared summary point for a session
- * - accumulateHandoff() adds handoffs to the anchor
- * - clearAnchor() finalizes and returns accumulated summaries
- * - getAnchorHandoff() retrieves accumulated summary without clearing
- *
- * @see docs/pi-boomerang-integration-plan.md
- */
-
-import type { HandoffSummary } from "./handoff-manager.ts";
-
-/**
- * Represents a shared summary point where multiple handoffs accumulate.
- */
-export interface Anchor {
-	/** Unique anchor identifier */
-	id: string;
-	/** Session ID this anchor belongs to */
-	sessionId: string;
-	/** Timestamp when anchor was created */
-	createdAt: number;
-	/** Accumulated handoffs */
-	handoffs: HandoffSummary[];
-	/** Initial context when anchor was set */
-	context: Record<string, unknown>;
-}
-
-/**
- * Options for AnchorManager.
- */
-export interface AnchorManagerOptions {
-	/** Custom event emitter for anchor events */
-	eventEmitter?: AnchorEventEmitter;
-}
-
-/**
- * Event emitter interface for anchor lifecycle events.
- */
-export interface AnchorEventEmitter {
-	emit(event: string, data: unknown): void;
-}
-
-/**
- * Event data for anchor lifecycle events.
- */
-export interface AnchorEventData {
-	anchor: Anchor;
-}
-
-export interface AnchorClearedEventData {
-	anchorId: string;
-	accumulated: HandoffSummary;
-}
-
-export interface AnchorHandoffAccumulatedEventData {
-	anchorId: string;
-	handoff: HandoffSummary;
-}
-
-/**
- * AnchorManager creates shared summary points where multiple handoffs accumulate.
- * This enables scenarios where multiple agents contribute to a shared summary
- * that is then passed to a parent or used for tree navigation.
- */
-export class AnchorManager {
-	private anchors: Map<string, Anchor> = new Map();
-	private sessionAnchors: Map<string, string> = new Map();
-	private options: AnchorManagerOptions;
-	private readonly MAX_ANCHORS = 1000;
-	private readonly TTL_MS = 300000; // 5 minutes
-
-	constructor(options: AnchorManagerOptions = {}) {
-		this.options = options;
-	}
-
-	/**
-	 * Set an anchor point for a session.
-	 * All subsequent handoffs will accumulate to this anchor.
-	 *
-	 * @param sessionId - The session ID to create anchor for
-	 * @param context - Initial context for the anchor
-	 * @returns The anchor ID
-	 */
-	setAnchor(sessionId: string, context: Record<string, unknown> = {}): string {
-		const anchorId = this.generateAnchorId();
-
-		// Evict expired or overflow anchors before adding new one
-		this.evictExpiredAnchors();
-		if (this.anchors.size >= this.MAX_ANCHORS) {
-			this.evictOldestAnchor();
-		}
-
-		const anchor: Anchor = {
-			id: anchorId,
-			sessionId,
-			createdAt: Date.now(),
-			handoffs: [],
-			context,
-		};
-
-		this.anchors.set(anchorId, anchor);
-		this.sessionAnchors.set(sessionId, anchorId);
-
-		this.options.eventEmitter?.emit("anchor:created", { anchor });
-
-		return anchorId;
-	}
-
-	/**
-	 * Get the current anchor for a session.
-	 *
-	 * @param sessionId - The session ID
-	 * @returns The anchor if exists, null otherwise
-	 */
-	getAnchor(sessionId: string): Anchor | null {
-		this.evictExpiredAnchors();
-		const anchorId = this.sessionAnchors.get(sessionId);
-		if (!anchorId) return null;
-		return this.anchors.get(anchorId) ?? null;
-	}
-
-	/**
-	 * Get the anchor ID for a session.
-	 *
-	 * @param sessionId - The session ID
-	 * @returns The anchor ID if exists, undefined otherwise
-	 */
-	getAnchorId(sessionId: string): string | undefined {
-		return this.sessionAnchors.get(sessionId);
-	}
-
-	/**
-	 * Clear an anchor and return the accumulated handoff summary.
-	 * This removes the anchor and returns merged handoffs.
-	 *
-	 * @param anchorId - The anchor ID to clear
-	 * @returns The accumulated handoff summary
-	 * @throws Error if anchor not found or no handoffs accumulated
-	 */
-	clearAnchor(anchorId: string): HandoffSummary {
-		const anchor = this.anchors.get(anchorId);
-
-		if (!anchor) {
-			throw new AnchorNotFoundError(anchorId);
-		}
-
-		const accumulated = this.accumulateHandoffs(anchor.handoffs);
-
-		// Clean up maps
-		this.sessionAnchors.delete(anchor.sessionId);
-		this.anchors.delete(anchorId);
-
-		this.options.eventEmitter?.emit("anchor:cleared", {
-			anchorId,
-			accumulated,
-		});
-
-		return accumulated;
-	}
-
-	/**
-	 * Clear anchor by session ID.
-	 *
-	 * @param sessionId - The session ID
-	 * @returns The accumulated handoff summary
-	 */
-	clearAnchorBySession(sessionId: string): HandoffSummary | null {
-		const anchorId = this.sessionAnchors.get(sessionId);
-		if (!anchorId) return null;
-		return this.clearAnchor(anchorId);
-	}
-
-	/**
-	 * Accumulate a handoff to an anchor.
-	 * If anchor doesn't exist, creates an implicit anchor.
-	 *
-	 * @param anchorId - The anchor ID
-	 * @param handoff - The handoff summary to accumulate
-	 */
-	accumulateHandoff(anchorId: string, handoff: HandoffSummary): void {
-		let anchor = this.anchors.get(anchorId);
-
-		// Create implicit anchor if doesn't exist - create directly with the given anchorId
-		if (!anchor) {
-			// Evict oldest anchor if at capacity
-			if (this.anchors.size >= MAX_ANCHORS) {
-				const oldest = this.anchors.keys().next().value;
-				if (oldest) {
-					this.anchors.delete(oldest);
-				}
-			}
-			const implicitAnchor: Anchor = {
-				id: anchorId,
-				sessionId: handoff.runId,
-				createdAt: Date.now(),
-				handoffs: [],
-				context: {},
-			};
-			this.anchors.set(anchorId, implicitAnchor);
-			anchor = implicitAnchor;
-		}
-
-		// Enforce handoff limit per anchor to prevent unbounded growth
-		if (anchor!.handoffs.length >= MAX_HANDOFFS_PER_ANCHOR) {
-			anchor!.handoffs.shift();
-		}
-		anchor!.handoffs.push(handoff);
-
-		this.options.eventEmitter?.emit("anchor:handoffAccumulated", {
-			anchorId: anchor!.id,
-			handoff,
-		});
-	}
-
-	/**
-	 * Accumulate handoff by session ID.
-	 *
-	 * @param sessionId - The session ID
-	 * @param handoff - The handoff summary to accumulate
-	 */
-	accumulateHandoffBySession(sessionId: string, handoff: HandoffSummary): void {
-		const anchorId = this.sessionAnchors.get(sessionId);
-		if (!anchorId) {
-			// Create new anchor for this session
-			const newAnchorId = this.setAnchor(sessionId);
-			this.accumulateHandoff(newAnchorId, handoff);
-		} else {
-			this.accumulateHandoff(anchorId, handoff);
-		}
-	}
-
-	/**
-	 * Get the accumulated handoff for an anchor without clearing it.
-	 *
-	 * @param anchorId - The anchor ID
-	 * @returns The accumulated handoff summary, or null if anchor not found or no handoffs
-	 */
-	getAnchorHandoff(anchorId: string): HandoffSummary | null {
-		const anchor = this.anchors.get(anchorId);
-		if (!anchor) return null;
-		if (anchor.handoffs.length === 0) return null;
-		return this.accumulateHandoffs(anchor.handoffs);
-	}
-
-	/**
-	 * Get accumulated handoff by session ID.
-	 *
-	 * @param sessionId - The session ID
-	 * @returns The accumulated handoff summary, or null if no anchor or handoffs
-	 */
-	getAnchorHandoffBySession(sessionId: string): HandoffSummary | null {
-		const anchorId = this.sessionAnchors.get(sessionId);
-		if (!anchorId) return null;
-		return this.getAnchorHandoff(anchorId);
-	}
-
-	/**
-	 * Get status information for an anchor.
-	 *
-	 * @param anchorId - The anchor ID
-	 * @returns Status object or null if anchor not found
-	 */
-	getAnchorStatus(anchorId: string): AnchorStatus | null {
-		const anchor = this.anchors.get(anchorId);
-		if (!anchor) return null;
-
-		return {
-			anchorId: anchor.id,
-			sessionId: anchor.sessionId,
-			createdAt: anchor.createdAt,
-			handoffCount: anchor.handoffs.length,
-			totalTokens: anchor.handoffs.reduce((sum, h) => sum + h.metrics.tokensUsed, 0),
-			totalDuration: anchor.handoffs.reduce((sum, h) => sum + h.metrics.duration, 0),
-			context: anchor.context,
-		};
-	}
-
-	/**
-	 * Get status by session ID.
-	 *
-	 * @param sessionId - The session ID
-	 * @returns Status object or null if no anchor
-	 */
-	getAnchorStatusBySession(sessionId: string): AnchorStatus | null {
-		const anchorId = this.sessionAnchors.get(sessionId);
-		if (!anchorId) return null;
-		return this.getAnchorStatus(anchorId);
-	}
-
-	/**
-	 * Check if an anchor has handoffs accumulated.
-	 *
-	 * @param anchorId - The anchor ID
-	 * @returns True if anchor has handoffs
-	 */
-	hasHandoffs(anchorId: string): boolean {
-		const anchor = this.anchors.get(anchorId);
-		return anchor ? anchor.handoffs.length > 0 : false;
-	}
-
-	/**
-	 * Get all anchors.
-	 *
-	 * @returns Array of all anchors
-	 */
-	getAllAnchors(): Anchor[] {
-		return Array.from(this.anchors.values());
-	}
-
-	/**
-	 * Clear all anchors.
-	 */
-	clearAll(): void {
-		this.anchors.clear();
-		this.sessionAnchors.clear();
-		this.options.eventEmitter?.emit("anchor:cleared_all", {});
-	}
-
-	/**
-	 * Merge multiple handoffs into a single accumulated summary.
-	 */
-	private accumulateHandoffs(handoffs: HandoffSummary[]): HandoffSummary {
-		if (handoffs.length === 0) {
-			throw new NoHandoffsError();
-		}
-
-		const allMetrics = handoffs.reduce(
-			(acc, h) => ({
-				tokensUsed: acc.tokensUsed + h.metrics.tokensUsed,
-				duration: acc.duration + h.metrics.duration,
-				iterations: acc.iterations + h.metrics.iterations,
-				toolsUsed: [...acc.toolsUsed, ...h.metrics.toolsUsed],
-			}),
-			{
-				tokensUsed: 0,
-				duration: 0,
-				iterations: 0,
-				toolsUsed: [] as string[],
-			},
-		);
-
-		// Deduplicate tools
-		const uniqueTools = [...new Set(allMetrics.toolsUsed)];
-
-		return {
-			taskId: `anchor-${handoffs[0].taskId}`,
-			runId: handoffs[0].runId,
-			timestamp: Date.now(),
-
-			task: `Accumulated: ${handoffs.map((h) => h.task).join(" → ")}`,
-			outcome: handoffs.every((h) => h.outcome === "success")
-				? "success"
-				: handoffs.some((h) => h.outcome === "failure")
-					? "failure"
-					: "partial",
-
-			filesCreated: [...new Set(handoffs.flatMap((h) => h.filesCreated))],
-			filesModified: [...new Set(handoffs.flatMap((h) => h.filesModified))],
-			filesDeleted: [...new Set(handoffs.flatMap((h) => h.filesDeleted))],
-
-			decisions: handoffs.flatMap((h) => h.decisions),
-			blockers: [...new Set(handoffs.flatMap((h) => h.blockers))],
-			nextSteps: handoffs.flatMap((h) => h.nextSteps),
-
-			metrics: {
-				tokensUsed: allMetrics.tokensUsed,
-				duration: allMetrics.duration,
-				iterations: allMetrics.iterations,
-				toolsUsed: uniqueTools,
-			},
-
-			contextSnapshot: handoffs.map((h) => h.contextSnapshot).join("\n---\n"),
-		};
-	}
-
-	/**
-	 * Generate a unique anchor ID.
-	 */
-	private generateAnchorId(): string {
-		return `anchor-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
-	}
-
-	/**
-	 * Evict expired anchors based on TTL.
-	 */
-	private evictExpiredAnchors(): void {
-		const now = Date.now();
-		for (const [anchorId, anchor] of this.anchors) {
-			if (now - anchor.createdAt > this.TTL_MS) {
-				this.sessionAnchors.delete(anchor.sessionId);
-				this.anchors.delete(anchorId);
-			}
-		}
-	}
-
-	/**
-	 * Evict the oldest anchor (LRU eviction when at max capacity).
-	 */
-	private evictOldestAnchor(): void {
-		let oldestAnchorId: string | null = null;
-		let oldestTime = Infinity;
-		for (const [anchorId, anchor] of this.anchors) {
-			if (anchor.createdAt < oldestTime) {
-				oldestTime = anchor.createdAt;
-				oldestAnchorId = anchorId;
-			}
-		}
-		if (oldestAnchorId) {
-			const anchor = this.anchors.get(oldestAnchorId);
-			if (anchor) {
-				this.sessionAnchors.delete(anchor.sessionId);
-			}
-			this.anchors.delete(oldestAnchorId);
-		}
-	}
-}
-
-/**
- * Status information for an anchor.
- */
-export interface AnchorStatus {
-	anchorId: string;
-	sessionId: string;
-	createdAt: number;
-	handoffCount: number;
-	totalTokens: number;
-	totalDuration: number;
-	context: Record<string, unknown>;
-}
-
-/**
- * Error thrown when an anchor is not found.
- */
-export class AnchorNotFoundError extends Error {
-	public readonly anchorId: string;
-
-	constructor(anchorId: string) {
-		super(`Anchor not found: ${anchorId}`);
-		this.name = "AnchorNotFoundError";
-		this.anchorId = anchorId;
-	}
-}
-
-/**
- * Error thrown when there are no handoffs to accumulate.
- */
-export class NoHandoffsError extends Error {
-	constructor() {
-		super("No handoffs to accumulate");
-		this.name = "NoHandoffsError";
-	}
-}
-
-/**
- * Create an AnchorManager with default options.
- */
-export function createAnchorManager(options?: AnchorManagerOptions): AnchorManager {
-	return new AnchorManager(options);
-}
-
-// Re-export HandoffSummary for consumers
-export type { HandoffSummary } from "./handoff-manager.ts";

package/src/runtime/async-marker.ts

@@ -1,32 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { atomicWriteJson } from "../state/atomic-write.ts";
-import type { TeamRunManifest } from "../state/types.ts";
-
-export interface AsyncStartMarker {
-	pid: number;
-	startedAt: string;
-}
-
-export function asyncStartMarkerPath(manifest: Pick<TeamRunManifest, "stateRoot">): string {
-	return path.join(manifest.stateRoot, "async.pid");
-}
-
-export function writeAsyncStartMarker(manifest: Pick<TeamRunManifest, "stateRoot">, marker: AsyncStartMarker): void {
-	atomicWriteJson(asyncStartMarkerPath(manifest), marker);
-}
-
-export function hasAsyncStartMarker(manifest: Pick<TeamRunManifest, "stateRoot">): boolean {
-	try {
-		const raw = JSON.parse(fs.readFileSync(asyncStartMarkerPath(manifest), "utf-8")) as Partial<AsyncStartMarker>;
-		return (
-			typeof raw.pid === "number" &&
-			Number.isInteger(raw.pid) &&
-			raw.pid > 0 &&
-			typeof raw.startedAt === "string" &&
-			raw.startedAt.length > 0
-		);
-	} catch {
-		return false;
-	}
-}