pi-crew 0.9.16 → 0.9.18

package/src/state/state-store.ts

@@ -1,21 +1,21 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { TeamRunManifest, TeamTaskState } from "./types.ts";
-import { canTransitionRunStatus } from "./contracts.ts";
-import { unregisterActiveRun } from "./active-run-registry.ts";
-import { atomicWriteJson, atomicWriteJsonAsync, atomicWriteJsonCoalesced, readJsonFile } from "./atomic-write.ts";
-import { appendEvent } from "./event-log.ts";
 import { DEFAULT_CACHE, DEFAULT_PATHS } from "../config/defaults.ts";
+import { errors } from "../errors.ts";
+import type { TeamConfig } from "../teams/team-config.ts";
 import { createRunId, createTaskId } from "../utils/ids.ts";
+import { logInternalError } from "../utils/internal-error.ts";
 import { findRepoRoot, projectCrewRoot, userCrewRoot } from "../utils/paths.ts";
 import { assertSafePathId, resolveContainedRelativePath, resolveRealContainedPath } from "../utils/safe-paths.ts";
-import { withRunLock, withRunLockSync } from "./locks.ts";
-import { logInternalError } from "../utils/internal-error.ts";
-import { errors } from "../errors.ts";
-import type { TeamConfig } from "../teams/team-config.ts";
-import type { WorkflowConfig } from "../workflows/workflow-config.ts";
 import { toPiSessionId } from "../utils/session-utils.ts";
+import type { WorkflowConfig } from "../workflows/workflow-config.ts";
+import { unregisterActiveRun } from "./active-run-registry.ts";
+import { atomicWriteJson, atomicWriteJsonAsync, atomicWriteJsonCoalesced, readJsonFile } from "./atomic-write.ts";
+import { canTransitionRunStatus } from "./contracts.ts";
+import { appendEvent } from "./event-log.ts";
 import { HealthStore } from "./health-store.ts";
+import { withRunLock, withRunLockSync } from "./locks.ts";
+import type { TeamRunManifest, TeamTaskState } from "./types.ts";
 
 /**
  * stat() the manifest with a brief retry on Windows for the AV-scan window.
@@ -42,7 +42,9 @@ function statManifestWithWindowsRetry(manifestPath: string): fs.Stats {
 			const code = (error as NodeJS.ErrnoException).code;
 			if (!retryable.has(code ?? "")) throw error;
 			const end = Date.now() + Math.min(8, 1 * 2 ** attempt);
-			while (Date.now() < end) { /* brief spin to ride out the AV scan window */ }
+			while (Date.now() < end) {
+				/* brief spin to ride out the AV scan window */
+			}
 		}
 	}
 	return fs.statSync(manifestPath); // last attempt — let caller's catch handle ENOENT
@@ -111,7 +113,10 @@ function setManifestCache(stateRoot: string, entry: ManifestCacheEntry): void {
 		let oldestTime = Infinity;
 		for (const [key, val] of manifestCache.entries()) {
 			const t = val.cachedAt ?? 0;
-			if (t < oldestTime) { oldestTime = t; oldestKey = key; }
+			if (t < oldestTime) {
+				oldestTime = t;
+				oldestKey = key;
+			}
 		}
 		if (!oldestKey) break;
 		manifestCache.delete(oldestKey);
@@ -151,7 +156,13 @@ function validateRunManifestPaths(cwd: string, runId: string, manifest: TeamRunM
 	// Issue 2 fix: Reject manifests missing status field to prevent undefined
 	// behavior in callers like canTransitionRunStatus(manifest.status, newStatus).
 	if (!manifest.status || typeof manifest.status !== "string") return false;
-	if (manifest.runId !== runId || manifest.stateRoot !== stateRoot || manifest.tasksPath !== tasksPath || manifest.eventsPath !== path.join(stateRoot, "events.jsonl")) return false;
+	if (
+		manifest.runId !== runId ||
+		manifest.stateRoot !== stateRoot ||
+		manifest.tasksPath !== tasksPath ||
+		manifest.eventsPath !== path.join(stateRoot, "events.jsonl")
+	)
+		return false;
 	const artifactsParent = path.join(scopeBaseRoot(cwd), DEFAULT_PATHS.state.artifactsSubdir);
 	const expectedArtifactsRoot = resolveContainedRelativePath(artifactsParent, runId, "runId");
 	if (manifest.artifactsRoot !== expectedArtifactsRoot) return false;
@@ -197,7 +208,10 @@ export function createTasksFromWorkflow(runId: string, workflow: WorkflowConfig,
 		const role = team.roles.find((candidate) => candidate.name === step.role);
 		const id = stepToTaskId.get(step.id) ?? createTaskId(step.id, index);
 		const dependencies = step.dependsOn ?? [];
-		const children = workflow.steps.filter((candidate) => candidate.dependsOn?.includes(step.id)).map((candidate) => stepToTaskId.get(candidate.id)).filter((childId): childId is string => childId !== undefined);
+		const children = workflow.steps
+			.filter((candidate) => candidate.dependsOn?.includes(step.id))
+			.map((candidate) => stepToTaskId.get(candidate.id))
+			.filter((childId): childId is string => childId !== undefined);
 		return {
 			id,
 			runId,
@@ -268,8 +282,13 @@ export function createRunManifest(params: {
 		// "unknown"). Include it explicitly in the thrown message so CI logs and
 		// production callers can see WHY the write failed instead of ": unknown".
 		const cause = result.error ? `: ${result.error}` : "";
-		throw errors.fileWrite(paths.stateRoot, { code: "EWRITEFAIL" } as NodeJS.ErrnoException)
-			.withContext(`saveManifestAndTasksAtomicSync: manifestWritten=${result.manifestWritten}, tasksWritten=${result.tasksWritten}${cause}`);
+		throw errors
+			.fileWrite(paths.stateRoot, {
+				code: "EWRITEFAIL",
+			} as NodeJS.ErrnoException)
+			.withContext(
+				`saveManifestAndTasksAtomicSync: manifestWritten=${result.manifestWritten}, tasksWritten=${result.tasksWritten}${cause}`,
+			);
 	}
 	appendEvent(paths.eventsPath, {
 		type: "run.created",
@@ -278,8 +297,16 @@ export function createRunManifest(params: {
 		metadata: {
 			seq: 1,
 			provenance: "team_runner",
-			sessionIdentity: { title: params.team.name, workspace: params.cwd, purpose: params.goal },
-			ownership: { owner: params.team.name, workflowScope: params.workflow?.name ?? "manual", watcherAction: "act" },
+			sessionIdentity: {
+				title: params.team.name,
+				workspace: params.cwd,
+				purpose: params.goal,
+			},
+			ownership: {
+				owner: params.team.name,
+				workflowScope: params.workflow?.name ?? "manual",
+				watcherAction: "act",
+			},
 			confidence: "high",
 		},
 	});
@@ -395,20 +422,34 @@ export function saveRunTasks(manifest: TeamRunManifest, tasks: TeamTaskState[]):
  * see the previous on-disk content while the write is still buffered).
  * Bulk update paths that fan out into multiple writer call sites are the
  * intended use case. Single-update + read-update loops (e.g.
- * persistSingleTaskUpdate) should keep using saveRunTasks.
+ * persistSingleTaskUpdate) should keep using saveRunTasks — OR call
+ * `flushPendingAtomicWrites()` immediately before their read to force
+ * any pending coalesced writes to land on disk first.
+ *
+ * (perf review 2026-07 F4) — now used by persistSingleTaskUpdate's
+ * non-terminal checkpoint path; that caller calls flushPendingAtomicWrites()
+ * before its read-modify-write load to defeat the stale-read window.
  */
 /** @internal */
-function saveRunTasksCoalesced(manifest: TeamRunManifest, tasks: TeamTaskState[]): void {
+export function saveRunTasksCoalesced(manifest: TeamRunManifest, tasks: TeamTaskState[]): void {
 	// FIX: Invalidate cache BEFORE atomic write to prevent stale cache serving.
 	invalidateRunCache(manifest.stateRoot);
-	try { fs.statSync(manifest.stateRoot); } catch { return; }
+	try {
+		fs.statSync(manifest.stateRoot);
+	} catch {
+		return;
+	}
 	atomicWriteJsonCoalesced(manifest.tasksPath, tasks);
 }
 
 export async function saveRunTasksAsync(manifest: TeamRunManifest, tasks: TeamTaskState[]): Promise<void> {
 	// FIX: Invalidate cache BEFORE atomic write to prevent stale cache serving.
 	invalidateRunCache(manifest.stateRoot);
-	try { fs.statSync(manifest.stateRoot); } catch { return; }
+	try {
+		fs.statSync(manifest.stateRoot);
+	} catch {
+		return;
+	}
 	await atomicWriteJsonAsync(manifest.tasksPath, tasks);
 }
 
@@ -490,18 +531,32 @@ export interface UpdateRunStatusOptions {
 	metadata?: Parameters<typeof appendEvent>[1]["metadata"];
 }
 
-export function updateRunStatus(manifest: TeamRunManifest, status: TeamRunManifest["status"], summary?: string, options: UpdateRunStatusOptions = {}): TeamRunManifest {
+export function updateRunStatus(
+	manifest: TeamRunManifest,
+	status: TeamRunManifest["status"],
+	summary?: string,
+	options: UpdateRunStatusOptions = {},
+): TeamRunManifest {
 	if (!canTransitionRunStatus(manifest.status, status)) {
 		throw errors.invalidStatusTransition(manifest.status, status);
 	}
-	const updated: TeamRunManifest = { ...manifest, status, updatedAt: new Date().toISOString(), summary: summary ?? manifest.summary };
+	const updated: TeamRunManifest = {
+		...manifest,
+		status,
+		updatedAt: new Date().toISOString(),
+		summary: summary ?? manifest.summary,
+	};
 	saveRunManifest(updated);
 	// Unregister from active-run-index when run reaches a terminal status.
 	// Without this, stale entries accumulate (e.g. integration tests in /tmp) and
 	// Pi UI shows ghost "queued" runs that are actually completed/failed/cancelled.
 	// Note: "blocked" is excluded because blocked runs can be unblocked later.
 	if (status === "completed" || status === "failed" || status === "cancelled") {
-		try { unregisterActiveRun(updated.runId); } catch { /* non-critical */ }
+		try {
+			unregisterActiveRun(updated.runId);
+		} catch {
+			/* non-critical */
+		}
 	}
 	appendEvent(updated.eventsPath, {
 		type: `run.${status}`,
@@ -510,8 +565,16 @@ export function updateRunStatus(manifest: TeamRunManifest, status: TeamRunManife
 		...(options.data ? { data: options.data } : {}),
 		metadata: {
 			provenance: "team_runner",
-			sessionIdentity: { title: updated.team, workspace: updated.cwd, purpose: updated.goal },
-			ownership: { owner: updated.team, workflowScope: updated.workflow ?? "manual", watcherAction: "act" },
+			sessionIdentity: {
+				title: updated.team,
+				workspace: updated.cwd,
+				purpose: updated.goal,
+			},
+			ownership: {
+				owner: updated.team,
+				workflowScope: updated.workflow ?? "manual",
+				watcherAction: "act",
+			},
 			confidence: "high",
 			...options.metadata,
 		},
@@ -574,12 +637,12 @@ export function loadRunManifestById(cwd: string, runId: string): { manifest: Tea
 	}
 	const tasksMtimeMs = tasksStat?.mtimeMs ?? 0;
 	if (
-		cached
-		&& cached.manifestMtimeMs === manifestStat.mtimeMs
-		&& cached.manifestSize === manifestStat.size
-		&& cached.tasksMtimeMs === tasksMtimeMs
-		&& cached.tasksSize === (tasksStat?.size ?? 0)
-		&& cached.generation === manifestCacheGeneration
+		cached &&
+		cached.manifestMtimeMs === manifestStat.mtimeMs &&
+		cached.manifestSize === manifestStat.size &&
+		cached.tasksMtimeMs === tasksMtimeMs &&
+		cached.tasksSize === (tasksStat?.size ?? 0) &&
+		cached.generation === manifestCacheGeneration
 	) {
 		// TTL eviction: expire stale entries even if mtime matches
 		// FIX: Also evict entries where cachedAt is undefined — such entries are
@@ -592,7 +655,7 @@ export function loadRunManifestById(cwd: string, runId: string): { manifest: Tea
 		} else if (!validateRunManifestPaths(cwd, runId, cached.manifest, stateRoot, tasksPath)) {
 			manifestCache.delete(stateRoot);
 			return undefined;
-			} else if (!fs.existsSync(tasksPath)) {
+		} else if (!fs.existsSync(tasksPath)) {
 			// Tasks file was deleted after cache was populated — this is a cache miss,
 			// not a manifest inconsistency. The cache check passes because
 			// tasksMtimeMs=0 and tasksSize=0 match a cache entry written when tasks.json
@@ -621,8 +684,11 @@ export function loadRunManifestById(cwd: string, runId: string): { manifest: Tea
 		const freshTasksStat = fs.existsSync(tasksPath) ? fs.statSync(tasksPath) : undefined;
 		tasks = readJsonFile<TeamTaskState[]>(tasksPath) ?? [];
 		// If size/mtime didn't change between stat and read, we're consistent.
-		if (freshStat.mtimeMs === manifestStat.mtimeMs && freshStat.size === manifestStat.size
-			&& (!freshTasksStat || (freshTasksStat.mtimeMs === tasksStat?.mtimeMs && freshTasksStat.size === tasksStat?.size))) {
+		if (
+			freshStat.mtimeMs === manifestStat.mtimeMs &&
+			freshStat.size === manifestStat.size &&
+			(!freshTasksStat || (freshTasksStat.mtimeMs === tasksStat?.mtimeMs && freshTasksStat.size === tasksStat?.size))
+		) {
 			break;
 		}
 		attempts += 1;
@@ -637,7 +703,9 @@ export function loadRunManifestById(cwd: string, runId: string): { manifest: Tea
 		// Round 19: downgrade to debug — retry-loop instability is expected under
 		// concurrent writes (live team runs constantly append to tasks.json).
 		// This is best-effort by design; strict consistency requires withRunLock().
-		console.debug(`[state-store] loadRunManifestById: retry loop detected instability for run ${runId} after ${attempts} attempt(s) — best-effort only, use withRunLock() for strict consistency`);
+		console.debug(
+			`[state-store] loadRunManifestById: retry loop detected instability for run ${runId} after ${attempts} attempt(s) — best-effort only, use withRunLock() for strict consistency`,
+		);
 	}
 	// NOTE: manifest mtime may legitimately be >= tasks mtime because
 	// saveManifestAndTasksAtomicSync writes manifest before tasks. However,
@@ -659,7 +727,10 @@ export function loadRunManifestById(cwd: string, runId: string): { manifest: Tea
 	return { manifest, tasks: tasks ?? [] };
 }
 
-export async function loadRunManifestByIdAsync(cwd: string, runId: string): Promise<{ manifest: TeamRunManifest; tasks: TeamTaskState[] } | undefined> {
+export async function loadRunManifestByIdAsync(
+	cwd: string,
+	runId: string,
+): Promise<{ manifest: TeamRunManifest; tasks: TeamTaskState[] } | undefined> {
 	const stateRoot = resolveRunStateRoot(cwd, runId);
 	if (!stateRoot) return undefined;
 	const manifestPath = path.join(stateRoot, "manifest.json");
@@ -681,7 +752,14 @@ export async function loadRunManifestByIdAsync(cwd: string, runId: string): Prom
 		tasksStat = undefined;
 	}
 	const tasksMtimeMs = tasksStat?.mtimeMs ?? 0;
-	if (cached && cached.manifestMtimeMs === manifestStat.mtimeMs && cached.manifestSize === manifestStat.size && cached.tasksMtimeMs === tasksMtimeMs && cached.tasksSize === (tasksStat?.size ?? 0) && cached.generation === manifestCacheGeneration) {
+	if (
+		cached &&
+		cached.manifestMtimeMs === manifestStat.mtimeMs &&
+		cached.manifestSize === manifestStat.size &&
+		cached.tasksMtimeMs === tasksMtimeMs &&
+		cached.tasksSize === (tasksStat?.size ?? 0) &&
+		cached.generation === manifestCacheGeneration
+	) {
 		// TTL eviction: expire stale entries even if mtime matches
 		// FIX: Also evict entries where cachedAt is undefined — such entries are
 		// effectively immortal otherwise (the `cached.cachedAt &&` check would skip
@@ -693,10 +771,10 @@ export async function loadRunManifestByIdAsync(cwd: string, runId: string): Prom
 		} else if (!validateRunManifestPaths(cwd, runId, cached.manifest, stateRoot, tasksPath)) {
 			manifestCache.delete(stateRoot);
 			return undefined;
-			} else if (!fs.existsSync(tasksPath)) {
-				// Tasks file was deleted after cache was populated — do not serve stale cache.
-				manifestCache.delete(stateRoot);
-				return undefined;
+		} else if (!fs.existsSync(tasksPath)) {
+			// Tasks file was deleted after cache was populated — do not serve stale cache.
+			manifestCache.delete(stateRoot);
+			return undefined;
 		} else {
 			return { manifest: cached.manifest, tasks: cached.tasks ?? [] };
 		}
@@ -714,8 +792,11 @@ export async function loadRunManifestByIdAsync(cwd: string, runId: string): Prom
 		const freshTasksStat = await fs.promises.stat(tasksPath).catch(() => undefined);
 		tasks = (await readJsonFileAsync<TeamTaskState[]>(tasksPath)) ?? [];
 		// If size/mtime didn't change between stat and read, we're consistent.
-		if (freshStat.mtimeMs === manifestStat.mtimeMs && freshStat.size === manifestStat.size
-			&& (!freshTasksStat || (freshTasksStat.mtimeMs === tasksStat?.mtimeMs && freshTasksStat.size === tasksStat?.size))) {
+		if (
+			freshStat.mtimeMs === manifestStat.mtimeMs &&
+			freshStat.size === manifestStat.size &&
+			(!freshTasksStat || (freshTasksStat.mtimeMs === tasksStat?.mtimeMs && freshTasksStat.size === tasksStat?.size))
+		) {
 			break;
 		}
 		attempts += 1;
@@ -730,7 +811,9 @@ export async function loadRunManifestByIdAsync(cwd: string, runId: string): Prom
 		// Round 19: downgrade to debug — retry-loop instability is expected under
 		// concurrent writes (live team runs constantly append to tasks.json).
 		// This is best-effort by design; strict consistency requires withRunLock().
-		console.debug(`[state-store] loadRunManifestByIdAsync: retry loop detected instability for run ${runId} after ${attempts} attempt(s) — best-effort only, use withRunLock() for strict consistency`);
+		console.debug(
+			`[state-store] loadRunManifestByIdAsync: retry loop detected instability for run ${runId} after ${attempts} attempt(s) — best-effort only, use withRunLock() for strict consistency`,
+		);
 	}
 	// NOTE: manifest mtime may legitimately be >= tasks mtime because
 	// saveManifestAndTasksAtomicSync writes manifest before tasks. However,
@@ -742,6 +825,13 @@ export async function loadRunManifestByIdAsync(cwd: string, runId: string): Prom
 	// It does not indicate corruption on its own.
 
 	if (!manifest || !validateRunManifestPaths(cwd, runId, manifest, stateRoot, tasksPath)) return undefined;
-	setManifestCache(stateRoot, { manifest, tasks: tasks ?? [], manifestMtimeMs: manifestStat.mtimeMs, manifestSize: manifestStat.size, tasksMtimeMs, tasksSize: tasksStat?.size ?? 0 });
+	setManifestCache(stateRoot, {
+		manifest,
+		tasks: tasks ?? [],
+		manifestMtimeMs: manifestStat.mtimeMs,
+		manifestSize: manifestStat.size,
+		tasksMtimeMs,
+		tasksSize: tasksStat?.size ?? 0,
+	});
 	return { manifest, tasks: tasks ?? [] };
 }

package/src/state/task-claims.ts

@@ -8,7 +8,11 @@ export interface TaskClaimState {
 }
 
 export function createTaskClaim(owner: string, leaseMs = 5 * 60_000, now = new Date()): TaskClaimState {
-	return { owner, token: randomUUID(), leasedUntil: new Date(now.getTime() + leaseMs).toISOString() };
+	return {
+		owner,
+		token: randomUUID(),
+		leasedUntil: new Date(now.getTime() + leaseMs).toISOString(),
+	};
 }
 
 export function isTaskClaimExpired(claim: TaskClaimState | undefined, now = new Date()): boolean {
@@ -43,7 +47,13 @@ export function releaseTaskClaim<T extends TeamTaskState>(task: T, owner: string
 	return { ...task, claim: undefined };
 }
 
-export function transitionClaimedTaskStatus<T extends TeamTaskState>(task: T, owner: string, token: string, status: T["status"], now = new Date()): T {
+export function transitionClaimedTaskStatus<T extends TeamTaskState>(
+	task: T,
+	owner: string,
+	token: string,
+	status: T["status"],
+	now = new Date(),
+): T {
 	if (!canUseTaskClaim(task, owner, token, now)) {
 		throw new Error(`Task '${task.id}' claim is not held by '${owner}' or has expired.`);
 	}

package/src/state/tiered-eval.ts

@@ -1,15 +1,15 @@
 /**
  * Tiered Evaluation System
- * 
+ *
  * Inspired by agent-eval's judge tiers, this module provides a hierarchical
  * evaluation system where checks are grouped by computational cost and reliability:
- * 
+ *
  * - Tier 1 (deterministic): Fast checks (~1s timeout) - file exists, parse errors, etc.
  * - Tier 2 (pattern): Medium checks (~5s timeout) - grep, regex, structural checks
  * - Tier 3 (llm): Expensive checks (~60s timeout) - LLM-based evaluation
  */
 
-import type { EvalTier, TierConfig, EvalResult } from "./types-eval.ts";
+import type { EvalResult, EvalTier, TierConfig } from "./types-eval.ts";
 
 /**
  * Default tier configurations with increasing timeouts for more expensive evaluations.
@@ -40,7 +40,7 @@ export const TIER_CONFIGS: Record<EvalTier, TierConfig> = {
  */
 export const DEFAULT_TIER_CONFIGS = TIER_CONFIGS;
 
-export type { EvalTier, TierConfig, EvalResult };
+export type { EvalResult, EvalTier, TierConfig };
 
 /**
  * Individual evaluation check with its assigned tier.
@@ -99,21 +99,21 @@ export interface TieredEvalResult {
 /**
  * TieredEvalRunner executes evaluation checks in tiered order,
  * with appropriate timeouts for each tier level.
- * 
+ *
  * Supports two execution modes:
  * - runTieredEval: Runs all checks regardless of failures
  * - runTieredEvalFailFast: Stops at first failure (like ECC promotion gates)
- * 
+ *
  * @example
  * ```typescript
  * const runner = new TieredEvalRunner();
- * 
+ *
  * // Run all checks
  * const allResults = await runner.runTieredEval('task-1', [
  *   { tier: 1, check: () => fs.existsSync('output.json') },
  *   { tier: 2, check: async () => (await run('grep', ['pattern', 'output.json'])).exitCode === 0 }
  * ]);
- * 
+ *
  * // Fail-fast mode
  * const failFastResult = await runner.runTieredEvalFailFast('task-2', [
  *   { tier: 1, check: () => fs.existsSync('output.json') },
@@ -129,7 +129,7 @@ export class TieredEvalRunner {
 
 	/**
 	 * Creates a new TieredEvalRunner instance.
-	 * 
+	 *
 	 * @param config - Optional configuration to override defaults
 	 */
 	constructor(config?: TieredEvalRunnerConfig) {
@@ -154,7 +154,7 @@ export class TieredEvalRunner {
 
 	/**
 	 * Gets the effective timeout for a given tier.
-	 * 
+	 *
 	 * @param tier - The evaluation tier
 	 * @returns The timeout in milliseconds (after multiplier is applied)
 	 */
@@ -164,7 +164,7 @@ export class TieredEvalRunner {
 
 	/**
 	 * Gets the configuration for a specific tier.
-	 * 
+	 *
 	 * @param tier - The evaluation tier
 	 * @returns The tier configuration
 	 */
@@ -174,15 +174,12 @@ export class TieredEvalRunner {
 
 	/**
 	 * Runs a check with the specified timeout.
-	 * 
+	 *
 	 * @param check - The check function to run
 	 * @param tier - The tier this check belongs to
 	 * @returns The result of the check
 	 */
-	private async runCheckWithTimeout(
-		check: () => Promise<boolean> | boolean,
-		tier: EvalTier,
-	): Promise<CheckResult> {
+	private async runCheckWithTimeout(check: () => Promise<boolean> | boolean, tier: EvalTier): Promise<CheckResult> {
 		const timeout = this.getTimeout(tier);
 		const startTime = Date.now();
 
@@ -228,11 +225,11 @@ export class TieredEvalRunner {
 
 	/**
 	 * Runs all evaluation checks and returns results for each.
-	 * 
+	 *
 	 * @param taskId - Identifier for the task being evaluated
 	 * @param checks - Array of checks to run, each with a tier assignment
 	 * @returns Array of evaluation results for each check
-	 * 
+	 *
 	 * @example
 	 * ```typescript
 	 * const results = await runner.runTieredEval('task-123', [
@@ -240,19 +237,20 @@ export class TieredEvalRunner {
 	 *   { tier: 2, check: async () => (await grep('output.json', 'pattern')).found },
 	 *   { tier: 3, check: async () => llmJudge.evaluate(output) }
 	 * ]);
-	 * 
+	 *
 	 * // Check if all passed
 	 * const allPassed = results.every(r => r.passed);
 	 * ```
 	 */
 	async runTieredEval(
 		taskId: string,
-		checks: Array<{ tier: EvalTier; check: () => Promise<boolean> | boolean }>,
+		checks: Array<{
+			tier: EvalTier;
+			check: () => Promise<boolean> | boolean;
+		}>,
 	): Promise<EvalResult[]> {
 		// Sort checks by tier if configured (lower tiers first)
-		const sortedChecks = this.sortByTier
-			? [...checks].sort((a, b) => a.tier - b.tier)
-			: checks;
+		const sortedChecks = this.sortByTier ? [...checks].sort((a, b) => a.tier - b.tier) : checks;
 
 		const results: EvalResult[] = [];
 
@@ -267,14 +265,14 @@ export class TieredEvalRunner {
 
 	/**
 	 * Runs evaluation checks in fail-fast mode, stopping at the first failure.
-	 * 
+	 *
 	 * This is useful for promotion gates where cheaper checks should run first
 	 * and any failure should stop the evaluation immediately.
-	 * 
+	 *
 	 * @param taskId - Identifier for the task being evaluated
 	 * @param checks - Array of checks to run, each with a tier assignment
 	 * @returns Array of evaluation results (may be shorter than input if fail-fast triggered)
-	 * 
+	 *
 	 * @example
 	 * ```typescript
 	 * const results = await runner.runTieredEvalFailFast('task-123', [
@@ -282,7 +280,7 @@ export class TieredEvalRunner {
 	 *   { tier: 2, check: async () => (await grep('output.json', 'pattern')).found },
 	 *   { tier: 3, check: async () => llmJudge.evaluate(output) }
 	 * ]);
-	 * 
+	 *
 	 * if (results.length < checks.length) {
 	 *   console.log(`Failed at tier ${results[results.length - 1].tier}`);
 	 * }
@@ -290,12 +288,13 @@ export class TieredEvalRunner {
 	 */
 	async runTieredEvalFailFast(
 		taskId: string,
-		checks: Array<{ tier: EvalTier; check: () => Promise<boolean> | boolean }>,
+		checks: Array<{
+			tier: EvalTier;
+			check: () => Promise<boolean> | boolean;
+		}>,
 	): Promise<EvalResult[]> {
 		// Sort checks by tier if configured (lower tiers first)
-		const sortedChecks = this.sortByTier
-			? [...checks].sort((a, b) => a.tier - b.tier)
-			: checks;
+		const sortedChecks = this.sortByTier ? [...checks].sort((a, b) => a.tier - b.tier) : checks;
 
 		const results: EvalResult[] = [];
 
@@ -315,7 +314,7 @@ export class TieredEvalRunner {
 
 	/**
 	 * Runs evaluation checks and returns a structured result object.
-	 * 
+	 *
 	 * @param taskId - Identifier for the task being evaluated
 	 * @param checks - Array of checks to run, each with a tier assignment
 	 * @param failFast - Whether to stop at first failure (default: false)
@@ -323,12 +322,13 @@ export class TieredEvalRunner {
 	 */
 	async runEval(
 		taskId: string,
-		checks: Array<{ tier: EvalTier; check: () => Promise<boolean> | boolean }>,
+		checks: Array<{
+			tier: EvalTier;
+			check: () => Promise<boolean> | boolean;
+		}>,
 		failFast = false,
 	): Promise<TieredEvalResult> {
-		const sortedChecks = this.sortByTier
-			? [...checks].sort((a, b) => a.tier - b.tier)
-			: checks;
+		const sortedChecks = this.sortByTier ? [...checks].sort((a, b) => a.tier - b.tier) : checks;
 
 		const results: CheckResult[] = [];
 		let totalDurationMs = 0;
@@ -361,9 +361,9 @@ export class TieredEvalRunner {
 
 	/**
 	 * Runs checks in parallel within each tier, but sequentially across tiers.
-	 * 
+	 *
 	 * This optimizes execution time when multiple checks exist at the same tier level.
-	 * 
+	 *
 	 * @param taskId - Identifier for the task being evaluated
 	 * @param checks - Array of checks to run
 	 * @param failFast - Whether to stop at first failure (default: false)
@@ -371,11 +371,20 @@ export class TieredEvalRunner {
 	 */
 	async runTieredEvalParallel(
 		taskId: string,
-		checks: Array<{ tier: EvalTier; check: () => Promise<boolean> | boolean }>,
+		checks: Array<{
+			tier: EvalTier;
+			check: () => Promise<boolean> | boolean;
+		}>,
 		failFast = false,
 	): Promise<TieredEvalResult> {
 		// Group checks by tier
-		const checksByTier = new Map<EvalTier, Array<{ check: () => Promise<boolean> | boolean; originalIndex: number }>>();
+		const checksByTier = new Map<
+			EvalTier,
+			Array<{
+				check: () => Promise<boolean> | boolean;
+				originalIndex: number;
+			}>
+		>();
 
 		checks.forEach((c, originalIndex) => {
 			const existing = checksByTier.get(c.tier) || [];
@@ -431,7 +440,7 @@ export class TieredEvalRunner {
 
 	/**
 	 * Creates a new runner with overridden tier configurations.
-	 * 
+	 *
 	 * @param overrides - Tier configurations to override
 	 * @returns A new TieredEvalRunner instance
 	 */
@@ -447,10 +456,10 @@ export class TieredEvalRunner {
 
 /**
  * Convenience function to create a TieredEvalRunner with default configuration.
- * 
+ *
  * @param config - Optional configuration overrides
  * @returns A new TieredEvalRunner instance
- * 
+ *
  * @example
  * ```typescript
  * const runner = createRunner({

package/src/state/types-eval.ts

@@ -1,12 +1,12 @@
 /**
  * Types for the Tiered Evaluation System
- * 
+ *
  * Inspired by agent-eval's judge tiers for hierarchical evaluation.
  */
 
 /**
  * Evaluation tiers with increasing computational cost.
- * 
+ *
  * - Tier 1: Deterministic, fast checks (file existence, parse errors)
  * - Tier 2: Pattern matching, structural checks (grep, regex)
  * - Tier 3: LLM-based evaluation for natural language checks