pi-harness-runtime 1.1.440 → 1.1.441

package/packages/jev-judge/tests/validation-ledger.test.ts

@@ -1,181 +0,0 @@
-/**
- * Tests for the validation ledger - the durable record of which tier ran.
- *
- * The ledger is the only mechanical answer to "did the final tier pass?", so
- * it must survive malformed input, report the latest run of a tier and never
- * throw into its caller.
- */
-
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { mkdtempSync, readFileSync, rmSync, writeFileSync, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import {
-	ValidationLedger,
-	defaultLedgerPath,
-	parseLedgerContent,
-	parseRunRecord,
-} from "../src/validation-ledger.js";
-import type { TodoItem } from "../src/todo-provider.js";
-
-let dir: string;
-let path: string;
-
-beforeEach(() => {
-	dir = mkdtempSync(join(tmpdir(), "validation-ledger-"));
-	path = join(dir, "validation-runs.jsonl");
-});
-
-afterEach(() => {
-	rmSync(dir, { recursive: true, force: true });
-});
-
-function itemWithPlan(metadata: Record<string, unknown>): TodoItem {
-	return {
-		id: 1,
-		subject: "staged work",
-		status: "in_progress",
-		metadata,
-	};
-}
-
-const PLAN = {
-	validationPlan: {
-		fast: { command: "bun test tests/fast", expectedDurationMs: 18_000, datasetSize: 100 },
-		full: { command: "bun test tests/full", expectedDurationMs: 2_400_000, datasetSize: 10_000 },
-		budgetMinutes: 90,
-		finalTierRequired: true,
-	},
-};
-
-describe("parseRunRecord", () => {
-	it("reads a complete record", () => {
-		const record = parseRunRecord(
-			JSON.stringify({
-				ts: "2026-10-24T00:00:00.000Z",
-				tier: "full",
-				status: "passed",
-				itemId: 3,
-				durationMs: 1200,
-			}),
-		);
-		expect(record?.tier).toBe("full");
-		expect(record?.status).toBe("passed");
-		expect(record?.itemId).toBe(3);
-		expect(record?.durationMs).toBe(1200);
-	});
-
-	it("rejects malformed lines", () => {
-		expect(parseRunRecord("")).toBeNull();
-		expect(parseRunRecord("not json")).toBeNull();
-		expect(parseRunRecord("[]")).toBeNull();
-		expect(parseRunRecord(JSON.stringify({ tier: "medium", status: "passed" }))).toBeNull();
-		expect(parseRunRecord(JSON.stringify({ tier: "fast", status: "weird" }))).toBeNull();
-	});
-});
-
-describe("parseLedgerContent", () => {
-	it("skips malformed lines and keeps the rest", () => {
-		const content = [
-			JSON.stringify({ ts: "2026-10-24T00:00:00.000Z", tier: "fast", status: "passed" }),
-			"garbage",
-			"",
-			JSON.stringify({ ts: "2026-10-24T00:01:00.000Z", tier: "full", status: "failed" }),
-		].join("\n");
-		const records = parseLedgerContent(content);
-		expect(records).toHaveLength(2);
-		expect(records[1].tier).toBe("full");
-	});
-});
-
-describe("ValidationLedger", () => {
-	it("writes NDJSON that can be read back", () => {
-		const ledger = new ValidationLedger({ path });
-		ledger.record({ tier: "fast", status: "passed", itemId: 1, durationMs: 500 });
-
-		const raw = readFileSync(path, "utf-8");
-		expect(raw.trim().split("\n")).toHaveLength(1);
-		expect(JSON.parse(raw.trim()).tier).toBe("fast");
-		expect(ledger.read()).toHaveLength(1);
-	});
-
-	it("keeps only the runs of the requested item", () => {
-		const ledger = new ValidationLedger({ path });
-		ledger.record({ tier: "fast", status: "passed", itemId: 1 });
-		ledger.record({ tier: "fast", status: "passed", itemId: 2 });
-		expect(ledger.runsFor(1)).toHaveLength(1);
-		expect(ledger.runsFor(3)).toHaveLength(0);
-	});
-
-	it("returns the latest run of a tier", () => {
-		const ledger = new ValidationLedger({ path });
-		ledger.record({ tier: "fast", status: "failed", itemId: 1, ts: "2026-10-24T00:00:00.000Z" });
-		ledger.record({ tier: "fast", status: "passed", itemId: 1, ts: "2026-10-24T00:05:00.000Z" });
-		const latest = ledger.latestFor(1, "fast");
-		expect(latest?.status).toBe("passed");
-	});
-
-	it("mirrors every record to the sink", () => {
-		const mirrored: string[] = [];
-		const ledger = new ValidationLedger({ path, onRecord: (r) => mirrored.push(r.tier) });
-		ledger.record({ tier: "fast", status: "passed", itemId: 1 });
-		ledger.record({ tier: "full", status: "passed", itemId: 1 });
-		expect(mirrored).toEqual(["fast", "full"]);
-	});
-
-	it("never throws when the sink throws", () => {
-		const ledger = new ValidationLedger({
-			path,
-			onRecord: () => {
-				throw new Error("sink is broken");
-			},
-		});
-		expect(() => ledger.record({ tier: "fast", status: "passed", itemId: 1 })).not.toThrow();
-		expect(ledger.read()).toHaveLength(1);
-	});
-
-	it("rotates the file when it grows past the limit", () => {
-		const ledger = new ValidationLedger({ path, maxBytes: 200 });
-		for (let i = 0; i < 10; i++) {
-			ledger.record({ tier: "fast", status: "passed", itemId: i, note: "x".repeat(50) });
-		}
-		expect(existsSync(`${path}.1`)).toBe(true);
-	});
-
-	it("reports a pending final tier until the full tier passed", () => {
-		const ledger = new ValidationLedger({ path });
-		const item = itemWithPlan(PLAN);
-
-		expect(ledger.stateFor(item).finalTierPending).toBe(true);
-		expect(ledger.isFinalTierPending(item)).toBe(true);
-
-		ledger.record({ tier: "fast", status: "passed", itemId: 1 });
-		expect(ledger.stateFor(item).finalTierPending).toBe(true);
-
-		ledger.record({ tier: "full", status: "failed", itemId: 1 });
-		expect(ledger.stateFor(item).finalTierPending).toBe(true);
-
-		ledger.record({ tier: "full", status: "passed", itemId: 1 });
-		expect(ledger.stateFor(item).finalTierPending).toBe(false);
-		expect(ledger.stateFor(item).full.status).toBe("passed");
-	});
-
-	it("reports no pending tier for an item without a plan", () => {
-		const ledger = new ValidationLedger({ path });
-		const item: TodoItem = { id: 9, subject: "plain", status: "in_progress" };
-		const state = ledger.stateFor(item);
-		expect(state.hasPlan).toBe(false);
-		expect(state.finalTierPending).toBe(false);
-	});
-
-	it("survives a truncated file", () => {
-		writeFileSync(path, '{"ts":"2026-10-24T00:00:00.000Z","tier":"fast","status":"passed"}\n{"ts":"2026-10-2');
-		const ledger = new ValidationLedger({ path });
-		expect(ledger.read()).toHaveLength(1);
-	});
-
-	it("uses a default path under the harness home", () => {
-		expect(defaultLedgerPath()).toContain(".pi-harness-runtime");
-		expect(defaultLedgerPath().endsWith("validation-runs.jsonl")).toBe(true);
-	});
-});

package/packages/jev-judge/tests/validation-plan.test.ts

@@ -1,170 +0,0 @@
-/**
- * Tests for the staged validation plan.
- *
- * The plan is what lets the harness say "run the cheap tier while the code
- * changes, run the expensive tier once at the end" instead of letting the
- * agent repeat a 40 minute regression after every fix.
- */
-
-import { describe, it, expect } from "bun:test";
-import {
-	parseValidationPlan,
-	formatValidationContext,
-	buildValidationSteerSuffix,
-	parseDurationMs,
-	formatDuration,
-	parseTier,
-} from "../src/validation-plan.js";
-import type { TodoItem } from "../src/todo-provider.js";
-
-function item(metadata?: Record<string, unknown>): TodoItem {
-	return {
-		id: 1,
-		subject: "seed data",
-		status: "in_progress",
-		metadata,
-	};
-}
-
-describe("parseValidationPlan", () => {
-	it("returns null when the todo declares no plan", () => {
-		expect(parseValidationPlan(item())).toBeNull();
-		expect(parseValidationPlan(item({ other: "value" }))).toBeNull();
-		expect(parseValidationPlan(null)).toBeNull();
-	});
-
-	it("parses object tiers with cost and dataset size", () => {
-		const plan = parseValidationPlan(
-			item({
-				validationPlan: {
-					fast: { command: "bun test fast", expectedDurationMs: 18000, datasetSize: 100 },
-					full: { command: "bun test full", expectedDurationMs: 2400000, datasetSize: 10000 },
-				},
-			}),
-		);
-		expect(plan?.fast?.command).toBe("bun test fast");
-		expect(plan?.fast?.expectedDurationMs).toBe(18000);
-		expect(plan?.fast?.datasetSize).toBe(100);
-		expect(plan?.full?.expectedDurationMs).toBe(2400000);
-	});
-
-	it("parses plain command strings as tiers", () => {
-		const plan = parseValidationPlan(
-			item({ validationPlan: { fast: "bun test fast", full: "bun test full" } }),
-		);
-		expect(plan?.fast?.command).toBe("bun test fast");
-		expect(plan?.full?.command).toBe("bun test full");
-	});
-
-	it("parses flat command aliases and duration strings", () => {
-		const plan = parseValidationPlan(
-			item({ validationPlan: { fastCommand: "bun test fast", fullCommand: "bun test full", budgetMinutes: 90 } }),
-		);
-		expect(plan?.fast?.command).toBe("bun test fast");
-		expect(plan?.full?.command).toBe("bun test full");
-		expect(plan?.budgetMinutes).toBe(90);
-	});
-
-	it("reads a duration given as a string", () => {
-		const plan = parseValidationPlan(
-			item({ validationPlan: { full: { command: "bun test full", expectedDuration: "40m" } } }),
-		);
-		expect(plan?.full?.expectedDurationMs).toBe(40 * 60 * 1000);
-	});
-
-	it("keeps finalTierRequired and notes", () => {
-		const plan = parseValidationPlan(
-			item({
-				validationPlan: {
-					fast: "bun test fast",
-					full: "bun test full",
-					finalTierRequired: true,
-					notes: "fast tier must cover the aggregate query",
-				},
-			}),
-		);
-		expect(plan?.finalTierRequired).toBe(true);
-		expect(plan?.notes).toBe("fast tier must cover the aggregate query");
-	});
-
-	it("returns null for a plan that declares nothing usable", () => {
-		expect(parseValidationPlan(item({ validationPlan: { fast: {} } }))).toBeNull();
-		expect(parseValidationPlan(item({ validationPlan: "not an object" }))).toBeNull();
-	});
-});
-
-describe("duration helpers", () => {
-	it("parses explicit units", () => {
-		expect(parseDurationMs("45s")).toBe(45_000);
-		expect(parseDurationMs("40m")).toBe(2_400_000);
-		expect(parseDurationMs("1h")).toBe(3_600_000);
-		expect(parseDurationMs("1h30m")).toBe(5_400_000);
-		expect(parseDurationMs("garbage")).toBeUndefined();
-		expect(parseDurationMs("")).toBeUndefined();
-	});
-
-	it("treats a bare number below 1000 as seconds", () => {
-		expect(parseDurationMs(45)).toBe(45_000);
-		expect(parseDurationMs(45_000)).toBe(45_000);
-	});
-
-	it("formats durations for a status line", () => {
-		expect(formatDuration(18_000)).toBe("18s");
-		expect(formatDuration(2_400_000)).toBe("40m");
-		expect(formatDuration(5_400_000)).toBe("1h 30m");
-		expect(formatDuration(3_600_000)).toBe("1h");
-	});
-});
-
-describe("parseTier", () => {
-	it("ignores empty tiers", () => {
-		expect(parseTier("", "fast")).toBeUndefined();
-		expect(parseTier({}, "fast")).toBeUndefined();
-		expect(parseTier(undefined, "fast")).toBeUndefined();
-	});
-
-	it("keeps a label-only tier", () => {
-		const tier = parseTier({ label: "unit tests" }, "fast");
-		expect(tier?.label).toBe("unit tests");
-	});
-});
-
-describe("formatValidationContext", () => {
-	it("is empty when there is no plan", () => {
-		expect(formatValidationContext({})).toBe("");
-		expect(buildValidationSteerSuffix(item())).toBe("");
-	});
-
-	it("states both tiers and the staged rule", () => {
-		const plan = parseValidationPlan(
-			item({
-				validationPlan: {
-					fast: { command: "bun test fast", expectedDurationMs: 18_000, datasetSize: 100 },
-					full: { command: "bun test full", expectedDurationMs: 2_400_000, datasetSize: 10_000 },
-					finalTierRequired: true,
-				},
-			}),
-		);
-		const text = formatValidationContext(plan!);
-		expect(text).toContain("fast=");
-		expect(text).toContain("full=");
-		expect(text).toContain("bun test fast");
-		expect(text).toContain("~18s");
-		expect(text).toContain("100 records");
-		expect(text).toContain("bun test full");
-		expect(text).toContain("~40m");
-		expect(text).toContain("10000 records");
-		expect(text).toContain("Run the fast tier after every edit");
-		expect(text).toContain("do not complete this todo");
-	});
-
-	it("reports the remaining budget", () => {
-		const plan = parseValidationPlan(
-			item({ validationPlan: { fast: "bun test fast", budgetMinutes: 90 } }),
-		);
-		const text = formatValidationContext(plan!, { elapsedMs: 12 * 60 * 1000 });
-		expect(text).toContain("Time budget: 90m");
-		expect(text).toContain("elapsed 12m");
-		expect(text).toContain("remaining 1h 18m");
-	});
-});

package/packages/jev-judge/tests/validation-tie-breaker.test.ts

@@ -1,88 +0,0 @@
-/**
- * Tests for the validation tie-breaker - the typed verdict that decides
- * whether an item may count as done.
- */
-
-import { describe, it, expect } from "bun:test";
-import { tieBreakValidation, formatTieBreaker } from "../src/validation-tie-breaker.js";
-import { summarizeValidationState } from "../src/validation-plan.js";
-import type { TodoItem } from "../src/todo-provider.js";
-
-const item: TodoItem = {
-	id: 4,
-	subject: "staged work",
-	status: "in_progress",
-	metadata: {
-		validationPlan: {
-			fast: { command: "bun test tests/fast" },
-			full: { command: "bun test tests/full" },
-			finalTierRequired: true,
-		},
-	},
-};
-
-const plan = {
-	fast: { kind: "fast" as const, command: "bun test tests/fast" },
-	full: { kind: "full" as const, command: "bun test tests/full" },
-	finalTierRequired: true,
-};
-
-describe("tieBreakValidation", () => {
-	it("reports no-plan for an item without a plan", () => {
-		const state = summarizeValidationState(null, []);
-		const verdict = tieBreakValidation({ id: 1, subject: "plain", status: "in_progress" }, state);
-		expect(verdict.verdict).toBe("no-plan");
-		expect(verdict.blocksCompletion).toBe(false);
-	});
-
-	it("blocks the completion while the final tier did not run", () => {
-		const state = summarizeValidationState(plan, []);
-		const verdict = tieBreakValidation(item, state);
-		expect(verdict.verdict).toBe("final-tier-pending");
-		expect(verdict.blocksCompletion).toBe(true);
-		expect(verdict.reason).toContain("has not run");
-	});
-
-	it("blocks the completion when the final tier failed", () => {
-		const state = summarizeValidationState(plan, [
-			{ ts: "2026-10-24T00:00:00.000Z", tier: "full", status: "failed" },
-		]);
-		const verdict = tieBreakValidation(item, state);
-		expect(verdict.verdict).toBe("final-tier-failed");
-		expect(verdict.blocksCompletion).toBe(true);
-		expect(verdict.tierStatus).toBe("failed");
-	});
-
-	it("allows the completion when the final tier passed", () => {
-		const state = summarizeValidationState(plan, [
-			{ ts: "2026-10-24T00:00:00.000Z", tier: "full", status: "passed" },
-		]);
-		const verdict = tieBreakValidation(item, state);
-		expect(verdict.verdict).toBe("complete");
-		expect(verdict.blocksCompletion).toBe(false);
-	});
-
-	it("allows the completion when no final tier is required", () => {
-		const state = summarizeValidationState(
-			{ fast: { kind: "fast", command: "bun test tests/fast" } },
-			[],
-		);
-		const verdict = tieBreakValidation(item, state);
-		expect(verdict.verdict).toBe("complete");
-		expect(verdict.blocksCompletion).toBe(false);
-	});
-
-	it("flags a plan that requires a final tier but declares none", () => {
-		const state = summarizeValidationState({ finalTierRequired: true }, []);
-		const verdict = tieBreakValidation(item, state);
-		expect(verdict.verdict).toBe("plan-incomplete");
-		expect(verdict.blocksCompletion).toBe(true);
-	});
-
-	it("formats the verdict for a log line", () => {
-		const state = summarizeValidationState(plan, []);
-		const verdict = tieBreakValidation(item, state);
-		expect(formatTieBreaker(verdict)).toContain("staged work");
-		expect(formatTieBreaker(verdict)).toContain("final-tier-pending");
-	});
-});

package/packages/laravel-plugin/test/analyzer.test.ts

@@ -1,220 +0,0 @@
-/**
- * Laravel Plugin Tests (RFC-0065)
- */
-
-import { describe, it, expect, afterEach } from "bun:test";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import * as os from "node:os";
-import { analyzeLaravel } from "../src/analyzer.js";
-
-const roots: string[] = [];
-
-async function mkdtemp(): Promise<string> {
-	const d = await fs.mkdtemp(path.join(os.tmpdir(), "laravel-plugin-"));
-	roots.push(d);
-	return d;
-}
-
-afterEach(async () => {
-	for (const d of roots) {
-		try {
-			await fs.rm(d, { recursive: true, force: true });
-		} catch {
-			/* ignore */
-		}
-	}
-	roots.length = 0;
-});
-
-describe("analyzeLaravel", () => {
-	it("returns null for non-laravel workspace", async () => {
-		const dir = await mkdtemp();
-		await fs.writeFile(path.join(dir, "package.json"), "{}", "utf-8");
-		expect(await analyzeLaravel(dir)).toBeNull();
-	});
-
-	it("detects laravel workspace via artisan", async () => {
-		const dir = await mkdtemp();
-		await fs.writeFile(
-			path.join(dir, "artisan"),
-			"#!/usr/bin/env php",
-			"utf-8",
-		);
-		await fs.writeFile(
-			path.join(dir, "composer.json"),
-			JSON.stringify({
-				name: "laravel/laravel",
-				require: { "laravel/framework": "^10.0" },
-			}),
-			"utf-8",
-		);
-		const result = await analyzeLaravel(dir);
-		expect(result).not.toBeNull();
-		expect(result!.framework.id).toBe("laravel");
-	});
-
-	it("detects laravel workspace via app structure", async () => {
-		const dir = await mkdtemp();
-		await fs.mkdir(path.join(dir, "app", "Http", "Controllers"), {
-			recursive: true,
-		});
-		await fs.writeFile(
-			path.join(dir, "composer.json"),
-			JSON.stringify({
-				require: { "laravel/framework": "^10.0" },
-			}),
-			"utf-8",
-		);
-		const result = await analyzeLaravel(dir);
-		expect(result).not.toBeNull();
-	});
-
-	it("extracts version from composer.json", async () => {
-		const dir = await mkdtemp();
-		await fs.writeFile(
-			path.join(dir, "artisan"),
-			"#!/usr/bin/env php",
-			"utf-8",
-		);
-		await fs.writeFile(
-			path.join(dir, "composer.json"),
-			JSON.stringify({
-				require: { "laravel/framework": "^10.0" },
-			}),
-			"utf-8",
-		);
-		const result = await analyzeLaravel(dir);
-		expect(result!.version).toBe("10.0");
-	});
-
-	it("lists controllers", async () => {
-		const dir = await mkdtemp();
-		await fs.mkdir(path.join(dir, "app", "Http", "Controllers"), {
-			recursive: true,
-		});
-		await fs.writeFile(
-			path.join(dir, "composer.json"),
-			JSON.stringify({
-				require: { "laravel/framework": "^10.0" },
-			}),
-			"utf-8",
-		);
-		await fs.writeFile(
-			path.join(dir, "app", "Http", "Controllers", "UserController.php"),
-			"class UserController {}",
-			"utf-8",
-		);
-		await fs.writeFile(
-			path.join(dir, "app", "Http", "Controllers", "PostController.php"),
-			"class PostController {}",
-			"utf-8",
-		);
-		const result = await analyzeLaravel(dir);
-		expect(result!.controllers).toContain("UserController");
-		expect(result!.controllers).toContain("PostController");
-	});
-
-	it("counts migrations", async () => {
-		const dir = await mkdtemp();
-		await fs.mkdir(path.join(dir, "database", "migrations"), {
-			recursive: true,
-		});
-		await fs.writeFile(
-			path.join(dir, "composer.json"),
-			JSON.stringify({
-				require: { "laravel/framework": "^10.0" },
-			}),
-			"utf-8",
-		);
-		await fs.writeFile(
-			path.join(
-				dir,
-				"database",
-				"migrations",
-				"2024_01_01_000000_create_users_table.php",
-			),
-			"create table",
-			"utf-8",
-		);
-		await fs.writeFile(
-			path.join(
-				dir,
-				"database",
-				"migrations",
-				"2024_01_02_000000_create_posts_table.php",
-			),
-			"create table",
-			"utf-8",
-		);
-		const result = await analyzeLaravel(dir);
-		expect(result!.migrations).toBe(2);
-	});
-
-	it("detects Sanctum auth", async () => {
-		const dir = await mkdtemp();
-		await fs.writeFile(
-			path.join(dir, "composer.json"),
-			JSON.stringify({
-				require: { "laravel/framework": "^10.0", "laravel/sanctum": "^3.0" },
-			}),
-			"utf-8",
-		);
-		await fs.writeFile(
-			path.join(dir, "artisan"),
-			"#!/usr/bin/env php",
-			"utf-8",
-		);
-		const result = await analyzeLaravel(dir);
-		expect(result!.authType).toBe("sanctum");
-	});
-
-	it("lists artisan commands", async () => {
-		const dir = await mkdtemp();
-		await fs.mkdir(path.join(dir, "app", "Console", "Commands"), {
-			recursive: true,
-		});
-		await fs.writeFile(
-			path.join(dir, "composer.json"),
-			JSON.stringify({
-				require: { "laravel/framework": "^10.0" },
-			}),
-			"utf-8",
-		);
-		await fs.writeFile(
-			path.join(dir, "app", "Console", "Commands", "SendEmailCommand.php"),
-			"class SendEmailCommand {}",
-			"utf-8",
-		);
-		const result = await analyzeLaravel(dir);
-		expect(result!.commands).toContain("SendEmailCommand");
-	});
-
-	it("extracts env variables", async () => {
-		const dir = await mkdtemp();
-		await fs.writeFile(
-			path.join(dir, ".env.example"),
-			`
-APP_NAME=Laravel
-APP_ENV=local
-APP_KEY=
-DB_CONNECTION=mysql
-MAIL_MAILER=smtp
-`.trim(),
-			"utf-8",
-		);
-		await fs.writeFile(
-			path.join(dir, "composer.json"),
-			JSON.stringify({
-				require: { "laravel/framework": "^10.0" },
-			}),
-			"utf-8",
-		);
-		await fs.mkdir(path.join(dir, "app", "Http", "Controllers"), {
-			recursive: true,
-		});
-		const result = await analyzeLaravel(dir);
-		expect(result!.envVars).toContain("APP_NAME");
-		expect(result!.envVars).toContain("DB_CONNECTION");
-	});
-});