pi-crew 0.9.51 → 0.9.52

package/src/state/event-reconstructor.ts

@@ -1,229 +0,0 @@
-/**
- * Event reconstructor — rebuilds task state from the append-only event log.
- *
- * Primary use-case: crash recovery when tasks.json is corrupted or missing.
- * The materialized tasks.json view is the primary source of truth; this
- * module provides a fallback reconstruction path from events.jsonl.
- *
- * Distilled from pi-autoresearch's append-only event log pattern.
- */
-import type { TeamEvent } from "./event-log.ts";
-import { readEvents } from "./event-log.ts";
-
-/** Task status values that can be reconstructed from lifecycle events. */
-const RECONSTRUCTABLE_STATUSES = new Set([
-	"created",
-	"queued",
-	"running",
-	"completed",
-	"failed",
-	"cancelled",
-	"skipped",
-	"waiting",
-	"needs_attention",
-]);
-
-/** Event types that carry task lifecycle state transitions. */
-const TASK_LIFECYCLE_EVENT_TYPES = new Set([
-	"task.created",
-	"task.started",
-	"task.completed",
-	"task.failed",
-	"task.skipped",
-	"task.cancelled",
-	"task.needs_attention",
-	"task.waiting",
-	"task.resumed",
-	"task.retried",
-	"task.blocked",
-	"task.progress",
-	"task.green",
-	"task.red",
-]);
-
-/** Terminal events that set finishedAt. */
-const TERMINAL_EVENTS = new Set(["task.completed", "task.failed", "task.cancelled", "task.skipped", "task.needs_attention"]);
-
-/** Mapping from event type to the reconstructed task status. */
-const EVENT_STATUS_MAP: Readonly<Record<string, string>> = {
-	"task.created": "created",
-	"task.started": "running",
-	"task.completed": "completed",
-	"task.failed": "failed",
-	"task.skipped": "skipped",
-	"task.cancelled": "cancelled",
-	"task.needs_attention": "needs_attention",
-	"task.waiting": "waiting",
-	"task.resumed": "running",
-	"task.retried": "queued",
-};
-
-/** Task state reconstructed purely from event log entries. */
-export interface ReconstructedTaskState {
-	/** Task identifier */
-	id: string;
-	/** Reconstructed status derived from the last lifecycle event */
-	status: string;
-	/** Timestamp of the task.started event, if observed */
-	startedAt?: string;
-	/** Timestamp of the terminal event (completed/failed/cancelled/skipped), if observed */
-	finishedAt?: string;
-	/** Error message from task.failed events */
-	error?: string;
-	/** Segment number from event data (for retry isolation) */
-	segment?: number;
-	/** Structured diagnostics from event data */
-	diagnostics?: Record<string, unknown>;
-	/** Numeric metrics from event data */
-	metrics?: Record<string, number>;
-}
-
-/** Result of reconstructing task state from events. */
-export interface ReconstructionResult {
-	/** Map of taskId → reconstructed task state */
-	tasks: Map<string, ReconstructedTaskState>;
-	/** Total number of events processed */
-	eventCount: number;
-	/** Number of malformed/unparseable events skipped */
-	corruptedCount: number;
-}
-
-/** Input: either a file path to read events from, or an in-memory array. */
-export type EventSource = string | TeamEvent[];
-
-function isTaskLifecycleEvent(event: TeamEvent): boolean {
-	return TASK_LIFECYCLE_EVENT_TYPES.has(event.type);
-}
-
-function statusFromEventType(eventType: string): string | undefined {
-	return EVENT_STATUS_MAP[eventType];
-}
-
-function safeNumber(value: unknown): number | undefined {
-	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-
-function safeRecord(value: unknown): Record<string, unknown> | undefined {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) {
-		return undefined;
-	}
-	return value as Record<string, unknown>;
-}
-
-function safeNumericRecord(value: unknown): Record<string, number> | undefined {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) {
-		return undefined;
-	}
-	const record: Record<string, number> = {};
-	for (const [key, val] of Object.entries(value as Record<string, unknown>)) {
-		if (typeof val === "number" && Number.isFinite(val)) {
-			record[key] = val;
-		}
-	}
-	if (Object.keys(record).length === 0) {
-		return undefined;
-	}
-	return record;
-}
-
-function parseEventLine(line: string): TeamEvent | undefined {
-	const trimmed = line.trim();
-	if (trimmed.length === 0) return undefined;
-	try {
-		const parsed = JSON.parse(trimmed);
-		if (typeof parsed !== "object" || parsed === null) return undefined;
-		if (typeof parsed.type !== "string" || typeof parsed.runId !== "string") return undefined;
-		return parsed as TeamEvent;
-	} catch {
-		return undefined;
-	}
-}
-
-/**
- * Process a stream of validated TeamEvents into reconstructed task states.
- * Shared logic for both file-based and line-based reconstruction.
- */
-function processEvents(events: Iterable<TeamEvent>, eventCount: number, corruptedCount: number): ReconstructionResult {
-	const tasks = new Map<string, ReconstructedTaskState>();
-
-	for (const event of events) {
-		if (typeof event.taskId !== "string" || event.taskId.length === 0) continue;
-		if (!isTaskLifecycleEvent(event)) continue;
-
-		const taskId = event.taskId;
-		let task = tasks.get(taskId);
-		if (!task) {
-			task = { id: taskId, status: "created" };
-			tasks.set(taskId, task);
-		}
-
-		const newStatus = statusFromEventType(event.type);
-		if (newStatus && RECONSTRUCTABLE_STATUSES.has(newStatus)) {
-			task.status = newStatus;
-		}
-
-		if (event.type === "task.started") {
-			task.startedAt = event.time;
-		}
-
-		if (TERMINAL_EVENTS.has(event.type)) {
-			task.finishedAt = event.time;
-		}
-
-		if (event.type === "task.failed" && event.message) {
-			task.error = event.message;
-		}
-
-		if (event.data) {
-			const segment = safeNumber(event.data.segment);
-			if (segment !== undefined) task.segment = segment;
-
-			const diagnostics = safeRecord(event.data.diagnostics);
-			if (diagnostics !== undefined) task.diagnostics = diagnostics;
-
-			const metrics = safeNumericRecord(event.data.metrics);
-			if (metrics !== undefined) task.metrics = metrics;
-		}
-	}
-
-	return { tasks, eventCount, corruptedCount };
-}
-
-/**
- * Reconstruct task states from an append-only event log.
- *
- * @param source - Either a file path to events.jsonl, or an array of TeamEvent objects
- * @returns Reconstruction result with task map, counts
- */
-export function reconstructTasksFromEvents(source: EventSource): ReconstructionResult {
-	const events: TeamEvent[] = typeof source === "string" ? readEvents(source) : source;
-	return processEvents(events, events.length, 0);
-}
-
-/**
- * Reconstruct task states from raw JSONL lines (string array).
- * Useful for testing without creating files.
- *
- * @param lines - Array of raw JSONL lines
- * @returns Reconstruction result
- */
-export function reconstructTasksFromLines(lines: string[]): ReconstructionResult {
-	let eventCount = 0;
-	let corruptedCount = 0;
-	const parsedEvents: TeamEvent[] = [];
-
-	for (const line of lines) {
-		const trimmed = line.trim();
-		if (trimmed.length === 0) continue;
-		const event = parseEventLine(trimmed);
-		if (event === undefined) {
-			corruptedCount++;
-			eventCount++;
-			continue;
-		}
-		parsedEvents.push(event);
-		eventCount++;
-	}
-
-	return processEvents(parsedEvents, eventCount, corruptedCount);
-}

package/src/state/gitignore-manager.ts

@@ -1,46 +0,0 @@
-/**
- * Manage .gitignore entries for the .crew directory.
- * Only adds entries if not already present; preserves existing content.
- */
-import * as fs from "node:fs";
-import { atomicWriteFile } from "./atomic-write.ts";
-
-/**
- * Entries to add to .gitignore for .crew directory management.
- *
- * - `/.crew/` and `/.crew` ignore the core state directory.
- * - Exceptions allow optional commit of artifacts/ and graphs/ (including their .gitkeep).
- */
-const CREW_GITIGNORE_ENTRIES = [
-	"/.crew/",
-	"/.crew",
-	"!.crew/artifacts/",
-	"!.crew/graphs/",
-	"!.crew/artifacts/.gitkeep",
-	"!.crew/graphs/.gitkeep",
-];
-
-/**
- * Update .gitignore with .crew entries. Creates the file if it doesn't exist.
- * Preserves all existing content.
- */
-export async function updateGitignore(gitignorePath: string): Promise<void> {
-	if (!fs.existsSync(gitignorePath)) {
-		atomicWriteFile(gitignorePath, CREW_GITIGNORE_ENTRIES.join("\n") + "\n");
-		return;
-	}
-
-	const current = fs.readFileSync(gitignorePath, "utf-8");
-	const existingLines = new Set(current.split("\n").map((line) => line.trim()));
-
-	let appended = "";
-	for (const entry of CREW_GITIGNORE_ENTRIES) {
-		if (!existingLines.has(entry)) {
-			appended += `\n${entry}`;
-		}
-	}
-
-	if (appended) {
-		fs.writeFileSync(gitignorePath, current + appended, "utf-8");
-	}
-}

package/src/state/health-store.ts

@@ -1,79 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { ManifestSummary } from "../runtime/task-health.ts";
-import { computeRunHealth } from "../runtime/task-health.ts";
-import { atomicWriteFile } from "./atomic-write.ts";
-
-// Relative to the crew root (`<cwd>/.crew`). BUG A fix (pts/2 hang
-// investigation 2026-06-16): this was `.crew/state/health`, which double-joined
-// to `<crewRoot>/state/.crew/state/health` because the caller passed the state
-// dir (not the crew root). Now the caller passes the real crew root, so this is
-// a plain `state/health` suffix.
-const HEALTH_DIR = "state/health";
-
-export interface HealthSnapshot {
-	runId: string;
-	timestamp: number;
-	gitRef?: string;
-	score: number;
-	grade: string;
-	penalties: { reason: string; deduction: number }[];
-}
-
-export class HealthStore {
-	private readonly crewRoot: string;
-	constructor(crewRoot: string) {
-		this.crewRoot = crewRoot;
-	}
-
-	private healthDir(): string {
-		return path.join(this.crewRoot, HEALTH_DIR);
-	}
-
-	saveSnapshot(manifest: ManifestSummary): HealthSnapshot {
-		const health = computeRunHealth(manifest);
-		const snapshot: HealthSnapshot = {
-			runId: manifest.runId,
-			timestamp: Date.now(),
-			score: health.score,
-			grade: health.grade,
-			penalties: health.penalties,
-		};
-		const dir = this.healthDir();
-		fs.mkdirSync(dir, { recursive: true });
-		const file = path.join(dir, `${manifest.runId}.json`);
-		// ST-2: atomic (temp + rename + fsync) — a crash mid-writeFileSync would truncate
-		// the snapshot and loadAllSnapshots() silently skips unparseable files.
-		atomicWriteFile(file, JSON.stringify(snapshot, null, 2) + "\n");
-		return snapshot;
-	}
-
-	loadLatestSnapshot(): HealthSnapshot | null {
-		const dir = this.healthDir();
-		if (!fs.existsSync(dir)) return null;
-		const snapshots = this.loadAllSnapshots();
-		if (snapshots.length === 0) return null;
-		// Sort by timestamp descending (most recent first)
-		snapshots.sort((a, b) => b.timestamp - a.timestamp);
-		return snapshots[0];
-	}
-
-	loadAllSnapshots(): HealthSnapshot[] {
-		const dir = this.healthDir();
-		if (!fs.existsSync(dir)) return [];
-		const snapshots = fs
-			.readdirSync(dir)
-			.filter((f) => f.endsWith(".json"))
-			.map((f) => {
-				try {
-					return JSON.parse(fs.readFileSync(path.join(dir, f), "utf8"));
-				} catch {
-					return null;
-				}
-			})
-			.filter(Boolean) as HealthSnapshot[];
-		// Sort by timestamp ascending (oldest first) for consistent ordering
-		snapshots.sort((a, b) => a.timestamp - b.timestamp);
-		return snapshots;
-	}
-}

package/src/state/hook-instinct-bridge.ts

@@ -1,94 +0,0 @@
-/**
- * Hook-to-instinct bridge - connects crewHooks events to instinct formation.
- * Auto-initializes when imported.
- */
-
-import { crewHooks } from "../runtime/crew-hooks.ts";
-
-// Lazy-initialized store and paths
-let storeInstance: import("./instinct-store.js").InstinctStore | null = null;
-let pathsInstance: typeof import("../utils/paths.js") | null = null;
-
-async function getStore() {
-	if (!storeInstance) {
-		// LAZY: defer dynamic import of ./instinct-store.js to its call site.
-		const { InstinctStore } = await import("./instinct-store.js");
-		// LAZY: defer dynamic import of ../utils/paths.js to its call site.
-		const paths = await import("../utils/paths.js");
-		storeInstance = new InstinctStore(paths.projectCrewRoot(process.cwd()));
-	}
-	return storeInstance;
-}
-
-async function getPaths() {
-	if (!pathsInstance) {
-		// LAZY: defer dynamic import of ../utils/paths.js to its call site.
-		pathsInstance = await import("../utils/paths.js");
-	}
-	return pathsInstance;
-}
-
-// Subscribe to events
-crewHooks.register("task_completed", async (event) => {
-	try {
-		const store = await getStore();
-		if (event.data?.role) {
-			store.saveInstinct({
-				trigger: `role:${event.data.role}`,
-				action: "prefer",
-				confidence: 0.6,
-				scope: "global",
-				evidence: [`task:${event.taskId} completed`],
-			});
-		}
-	} catch {
-		// Best-effort - don't crash on instinct formation failures
-	}
-});
-
-crewHooks.register("task_failed", async (event) => {
-	try {
-		const store = await getStore();
-		if (event.data?.role) {
-			store.saveInstinct({
-				trigger: `role:${event.data.role}`,
-				action: "avoid",
-				confidence: 0.3,
-				scope: "global",
-				evidence: [`task:${event.taskId} failed`],
-			});
-		}
-	} catch {
-		// Best-effort
-	}
-});
-
-crewHooks.register("run_completed", async (event) => {
-	try {
-		const store = await getStore();
-		if (event.data?.taskCount) {
-			store.saveInstinct({
-				trigger: "run_completed",
-				action: `completed:${event.data.taskCount}tasks`,
-				confidence: 0.6,
-				scope: "global",
-				evidence: [`run:${event.runId}`],
-			});
-		}
-	} catch {
-		// Best-effort
-	}
-});
-
-/**
- * Get instinct-based recommendations.
- */
-/** @internal */
-async function getInstinctRecommendations() {
-	try {
-		const store = await getStore();
-		return store.getInstincts().filter((i: { confidence: number }) => i.confidence >= 0.6);
-	} catch {
-		return [];
-	}
-}

package/src/state/hook-integrations.ts

@@ -1,51 +0,0 @@
-/**
- * Hook integrations - subscribes to crewHooks and provides observability.
- * Auto-initializes when imported.
- */
-
-import { crewHooks } from "../runtime/crew-hooks.ts";
-
-// Statistics
-let tasksCompleted = 0;
-let tasksFailed = 0;
-let runsCompleted = 0;
-let runsFailed = 0;
-
-// Subscribe to events (fire-and-forget)
-crewHooks.register("task_completed", () => {
-	tasksCompleted++;
-});
-
-crewHooks.register("task_failed", () => {
-	tasksFailed++;
-});
-
-crewHooks.register("run_completed", () => {
-	runsCompleted++;
-});
-
-crewHooks.register("run_failed", () => {
-	runsFailed++;
-});
-
-/**
- * Get current hook statistics.
- */
-export function getHookStats(): {
-	tasksCompleted: number;
-	tasksFailed: number;
-	runsCompleted: number;
-	runsFailed: number;
-} {
-	return { tasksCompleted, tasksFailed, runsCompleted, runsFailed };
-}
-
-/**
- * Reset statistics (useful for testing).
- */
-export function resetHookStats(): void {
-	tasksCompleted = 0;
-	tasksFailed = 0;
-	runsCompleted = 0;
-	runsFailed = 0;
-}