pi-harness-runtime 0.10.7 → 0.10.11

package/packages/autonomous-runtime/test/autonomous-runtime.test.ts

@@ -1,194 +0,0 @@
-/**
- * Tests for autonomous-runtime (RFC-0101 Phase 1)
- *
- * Covers: TaskRecord, TaskStatus, TaskLease, TaskInbox, LeaseManager
- */
-
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { mkdtempSync, rmSync, existsSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-import type { TaskRecord, TaskLease } from "../src/types.js";
-import { TaskInbox, LeaseManager } from "../src/index.js";
-
-const TEST_DIR = mkdtempSync(join(tmpdir(), "pi-autonomous-"));
-const INBOX_DIR = join(TEST_DIR, "inbox");
-const LEASE_DIR = join(TEST_DIR, "leases");
-
-afterEach(() => {
-	try {
-		rmSync(TEST_DIR, { recursive: true, force: true });
-	} catch {
-		// ignore
-	}
-});
-
-describe("TaskRecord types", () => {
-	it("accepts valid task shape", () => {
-		const task: TaskRecord = {
-			id: "task-1",
-			status: "pending",
-			title: "Test task",
-			created_at: new Date().toISOString(),
-			updated_at: new Date().toISOString(),
-			attempts: 0,
-		};
-		expect(task.id).toBe("task-1");
-		expect(task.status).toBe("pending");
-	});
-});
-
-describe("LeaseManager", () => {
-	it("grants exclusive lease to first worker", async () => {
-		const mgr = new LeaseManager({ leases_dir: LEASE_DIR });
-		const lease = await mgr.acquire("task-1", "worker-1");
-		expect(lease).not.toBeNull();
-		expect(lease!.worker_id).toBe("worker-1");
-		expect(lease!.task_id).toBe("task-1");
-		expect(lease!.acquired_at).toBeTruthy();
-	});
-
-	it("denies lease to second worker", async () => {
-		const mgr = new LeaseManager({ leases_dir: LEASE_DIR });
-		await mgr.acquire("task-1", "worker-1");
-		const second = await mgr.acquire("task-1", "worker-2");
-		expect(second).toBeNull();
-	});
-
-	it("releases and allows re-acquisition", async () => {
-		const mgr = new LeaseManager({ leases_dir: LEASE_DIR });
-		await mgr.acquire("task-1", "worker-1");
-		await mgr.release("task-1", "worker-1");
-		const next = await mgr.acquire("task-1", "worker-2");
-		expect(next).not.toBeNull();
-		expect(next!.worker_id).toBe("worker-2");
-	});
-
-	it("only owner can release", async () => {
-		const mgr = new LeaseManager({ leases_dir: LEASE_DIR });
-		await mgr.acquire("task-1", "worker-1");
-		const released = await mgr.release("task-1", "worker-2");
-		expect(released).toBe(false);
-	});
-
-	it("renewLease extends expiry if owner", async () => {
-		const mgr = new LeaseManager({ leases_dir: LEASE_DIR });
-		await mgr.acquire("task-1", "worker-1");
-		const renewed = await mgr.renewLease("task-1", "worker-1");
-		expect(renewed).toBe(true);
-	});
-
-	it("renewLease fails for non-owner", async () => {
-		const mgr = new LeaseManager({ leases_dir: LEASE_DIR });
-		await mgr.acquire("task-1", "worker-1");
-		const renewed = await mgr.renewLease("task-1", "worker-2");
-		expect(renewed).toBe(false);
-	});
-
-	it("getLease returns current lease", async () => {
-		const mgr = new LeaseManager({ leases_dir: LEASE_DIR });
-		const lease = await mgr.acquire("task-1", "worker-1");
-		const found = await mgr.getLease("task-1");
-		expect(found).toEqual(lease);
-	});
-
-	it("expired lease allows re-acquisition", async () => {
-		const mgr = new LeaseManager({ leases_dir: LEASE_DIR, default_ttl_ms: 1 });
-		await mgr.acquire("task-1", "worker-1");
-		// Wait for expiry
-		await new Promise((r) => setTimeout(r, 10));
-		const next = await mgr.acquire("task-1", "worker-2");
-		expect(next).not.toBeNull();
-		expect(next!.worker_id).toBe("worker-2");
-	});
-});
-
-describe("TaskInbox", () => {
-	it("accepts and returns pending tasks", async () => {
-		const inbox = new TaskInbox({ inbox_dir: INBOX_DIR });
-		await inbox.submit({
-			title: "Do the thing",
-			description: "A test task",
-			capability: "read",
-		});
-		const tasks = await inbox.getPending();
-		expect(tasks.length).toBe(1);
-		expect(tasks[0].status).toBe("pending");
-	});
-
-	it("assigns sequential integer IDs", async () => {
-		const inbox = new TaskInbox({ inbox_dir: INBOX_DIR });
-		await inbox.submit({ title: "Task 1", capability: "read" });
-		await inbox.submit({ title: "Task 2", capability: "read" });
-		const tasks = await inbox.getPending();
-		expect(tasks.length).toBe(2);
-		expect(tasks[0].id).toMatch(/^\d+$/);
-		expect(tasks[1].id).toMatch(/^\d+$/);
-		expect(Number(tasks[0].id)).toBeLessThan(Number(tasks[1].id));
-	});
-
-	it("transitions pending → running → completed", async () => {
-		const inbox = new TaskInbox({ inbox_dir: INBOX_DIR });
-		await inbox.submit({ title: "Test", capability: "read" });
-
-		const task = (await inbox.getPending())[0];
-		const started = await inbox.start(task.id);
-		expect(started.status).toBe("running");
-
-		const completed = await inbox.complete(task.id, { success: true });
-		expect(completed.status).toBe("completed");
-	});
-
-	it("fails a running task", async () => {
-		const inbox = new TaskInbox({ inbox_dir: INBOX_DIR });
-		await inbox.submit({ title: "Fail task", capability: "read" });
-		const task = (await inbox.getPending())[0];
-		await inbox.start(task.id);
-		const failed = await inbox.fail(task.id, "Intentional test failure");
-		expect(failed.status).toBe("failed");
-		expect(failed.error).toBe("Intentional test failure");
-	});
-
-	it("retries a failed task if max_attempts not exceeded", async () => {
-		const inbox = new TaskInbox({
-			inbox_dir: INBOX_DIR,
-			options: { max_attempts: 2 },
-		});
-		await inbox.submit({ title: "Retry task", capability: "read" });
-		const task = (await inbox.getPending())[0];
-		await inbox.start(task.id);
-		await inbox.fail(task.id, "First attempt failed");
-		const retried = (await inbox.getPending()).find((t) => t.id === task.id);
-		expect(retried).not.toBeUndefined();
-		expect(retried!.attempts).toBe(1);
-	});
-
-	it("does not retry if max_attempts exceeded", async () => {
-		const inbox = new TaskInbox({
-			inbox_dir: INBOX_DIR,
-			options: { max_attempts: 1 },
-		});
-		await inbox.submit({ title: "No retry task", capability: "read" });
-		const task = (await inbox.getPending())[0];
-		await inbox.start(task.id);
-		await inbox.fail(task.id, "Final failure");
-		const retried = await inbox.getTask(task.id);
-		expect(retried?.status).toBe("failed");
-		expect(retried?.attempts).toBe(1);
-	});
-
-	it("getTask returns specific task by id", async () => {
-		const inbox = new TaskInbox({ inbox_dir: INBOX_DIR });
-		await inbox.submit({ title: "Specific task", capability: "read" });
-		const [task] = await inbox.getPending();
-		const found = await inbox.getTask(task.id);
-		expect(found?.id).toBe(task.id);
-	});
-
-	it("returns null for non-existent task", async () => {
-		const inbox = new TaskInbox({ inbox_dir: INBOX_DIR });
-		const found = await inbox.getTask("nonexistent");
-		expect(found).toBeNull();
-	});
-});

package/packages/autonomous-runtime/test/inbox.test.mjs

@@ -1,266 +0,0 @@
-/**
- * Autonomous Runtime — tests for Phase 1 (RFC-0101 §1-4)
- * Plain JS (bun native test globals)
- */
-import { mkdirSync, rmSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { TaskInbox } from "../src/index.js";
-import { LeaseManager } from "../src/index.js";
-
-let testDir;
-
-function makeTask(overrides = {}) {
-	const id = `task-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
-	const now = new Date().toISOString();
-	return {
-		id,
-		objective: `Test task ${id}`,
-		acceptanceCriteria: ["criterion 1"],
-		source: { kind: "manual", createdBy: "test" },
-		priority: 2,
-		capabilities: ["llm.invoke"],
-		approvalClass: "automatic_read_only",
-		status: "queued",
-		attempts: 0,
-		maxAttempts: 3,
-		createdAt: now,
-		updatedAt: now,
-		history: [],
-		...overrides,
-	};
-}
-
-beforeEach(() => {
-	testDir = join(
-		tmpdir(),
-		`pi-harness-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-	);
-	mkdirSync(testDir, { recursive: true });
-});
-
-afterEach(() => {
-	try {
-		rmSync(testDir, { recursive: true, force: true });
-	} catch {
-		/* ignore */
-	}
-});
-
-const tasksPath = () => join(testDir, "tasks.jsonl");
-const leasesDir = () => join(testDir, "claimed");
-
-// ─── TaskInbox ────────────────────────────────────────────────────────────────
-
-describe("TaskInbox", () => {
-	it("append writes one JSONL line", () => {
-		const inbox = new TaskInbox({ tasksPath: tasksPath() });
-		inbox.append(makeTask());
-		const content = readFileSync(tasksPath(), "utf8");
-		const lines = content.trim().split("\n").filter(Boolean);
-		expect(lines).toHaveLength(1);
-		expect(() => JSON.parse(lines[0])).not.toThrow();
-	});
-
-	it("append rejects duplicate ids", () => {
-		const inbox = new TaskInbox({ tasksPath: tasksPath() });
-		const task = makeTask();
-		inbox.append(task);
-		expect(() => inbox.append(task)).toThrow();
-	});
-
-	it("list returns tasks sorted by priority then createdAt", () => {
-		const inbox = new TaskInbox({ tasksPath: tasksPath() });
-		inbox.append(makeTask({ id: "a", priority: 1 }));
-		inbox.append(makeTask({ id: "b", priority: 2 }));
-		inbox.append(
-			makeTask({
-				id: "c",
-				priority: 1,
-				createdAt: new Date(Date.now() + 1000).toISOString(),
-			}),
-		);
-		expect(inbox.list().map((t) => t.id)).toEqual(["a", "c", "b"]);
-	});
-
-	it("list filters by status", () => {
-		const inbox = new TaskInbox({ tasksPath: tasksPath() });
-		inbox.append(makeTask({ id: "queued-1", status: "queued" }));
-		inbox.append(makeTask({ id: "running-1", status: "running" }));
-		inbox.append(makeTask({ id: "completed-1", status: "completed" }));
-		expect(inbox.list({ status: "queued" }).map((t) => t.id)).toEqual([
-			"queued-1",
-		]);
-	});
-
-	it("get returns a task by id", () => {
-		const inbox = new TaskInbox({ tasksPath: tasksPath() });
-		const task = makeTask({ id: "find-me" });
-		inbox.append(task);
-		expect(inbox.get("find-me")?.id).toBe("find-me");
-		expect(inbox.get("not-found")).toBeNull();
-	});
-
-	it("transition updates status and appends history", () => {
-		const inbox = new TaskInbox({ tasksPath: tasksPath() });
-		const task = makeTask();
-		inbox.append(task);
-		const updated = inbox.transition(task.id, "running");
-		expect(updated.status).toBe("running");
-		expect(updated.history).toHaveLength(1);
-		expect(updated.history[0].kind).toBe("transitioned");
-	});
-
-	it("transition throws for unknown tasks", () => {
-		const inbox = new TaskInbox({ tasksPath: tasksPath() });
-		expect(() => inbox.transition("does-not-exist", "running")).toThrow();
-	});
-
-	it("complete marks status and sets result", () => {
-		const inbox = new TaskInbox({ tasksPath: tasksPath() });
-		const task = makeTask();
-		inbox.append(task);
-		const result = {
-			taskId: task.id,
-			status: "completed",
-			acceptanceCriteriaMet: [],
-			durationMs: 1000,
-		};
-		const updated = inbox.complete(task.id, result);
-		expect(updated.status).toBe("completed");
-		expect(updated.result).toEqual(result);
-	});
-
-	it("fail increments attempts", () => {
-		const inbox = new TaskInbox({ tasksPath: tasksPath() });
-		const task = makeTask();
-		inbox.append(task);
-		const updated = inbox.fail(task.id, "Something went wrong");
-		expect(updated.status).toBe("retrying");
-		expect(updated.failureReason).toBe("Something went wrong");
-		expect(updated.attempts).toBe(1);
-	});
-
-	it("fail promotes to dead_letter when maxAttempts reached", () => {
-		const inbox = new TaskInbox({ tasksPath: tasksPath() });
-		const task = makeTask({ attempts: 2, maxAttempts: 3 });
-		inbox.append(task);
-		const updated = inbox.fail(task.id, "Final failure");
-		expect(updated.status).toBe("dead_letter");
-		expect(updated.failureReason).toBe("Final failure");
-	});
-
-	it("stats returns counts by status", () => {
-		const inbox = new TaskInbox({ tasksPath: tasksPath() });
-		inbox.append(makeTask({ id: "a", status: "queued" }));
-		inbox.append(makeTask({ id: "b", status: "queued" }));
-		inbox.append(makeTask({ id: "c", status: "running" }));
-		inbox.append(makeTask({ id: "d", status: "completed" }));
-		const stats = inbox.stats();
-		expect(stats["queued"]).toBe(2);
-		expect(stats["running"]).toBe(1);
-		expect(stats["completed"]).toBe(1);
-	});
-});
-
-// ─── LeaseManager ─────────────────────────────────────────────────────────────
-
-describe("LeaseManager", () => {
-	it("claim writes a lease file atomically", () => {
-		const lm = new LeaseManager({ leasesDir: leasesDir() });
-		const lease = lm.claim("task-1", "worker-1");
-		expect(lease).not.toBeNull();
-		expect(lease.taskId).toBe("task-1");
-		expect(lease.workerId).toBe("worker-1");
-		expect(lease.attempt).toBe(1);
-		expect(lease.acquiredAt).toBeTruthy();
-		expect(lease.expiresAt).toBeTruthy();
-	});
-
-	it("claim returns null when already claimed by another worker", () => {
-		const lm = new LeaseManager({ leasesDir: leasesDir() });
-		// Worker-1 claims first, worker-2 tries immediately after.
-		// Atomic rename guarantees only one succeeds.
-		const first = lm.claim("task-1", "worker-1");
-		expect(first).not.toBeNull();
-		const second = lm.claim("task-1", "worker-2");
-		expect(second).toBeNull();
-	});
-
-	it("heartbeat extends expiry", async () => {
-		const lm = new LeaseManager({ leasesDir: leasesDir() });
-		lm.claim("task-1", "worker-1");
-		const before = new Date(lm.get("task-1").expiresAt).getTime();
-		await new Promise((r) => setTimeout(r, 50));
-		const refreshed = lm.heartbeat("task-1", "worker-1");
-		expect(refreshed).not.toBeNull();
-		const after = new Date(refreshed.expiresAt).getTime();
-		expect(after).toBeGreaterThan(before - 500);
-	});
-
-	it("heartbeat rejects wrong worker", () => {
-		const lm = new LeaseManager({ leasesDir: leasesDir() });
-		lm.claim("task-1", "worker-1");
-		expect(() => lm.heartbeat("task-1", "wrong-worker")).toThrow();
-	});
-
-	it("release removes the lease file", () => {
-		const lm = new LeaseManager({ leasesDir: leasesDir() });
-		lm.claim("task-1", "worker-1");
-		lm.release("task-1", "worker-1");
-		expect(lm.get("task-1")).toBeNull();
-	});
-
-	it("reapAndRelease removes expired leases", async () => {
-		const lm = new LeaseManager({ leasesDir: leasesDir(), leaseTtlMs: 50 });
-		lm.claim("task-1", "worker-1");
-		lm.claim("task-2", "worker-2");
-		await new Promise((r) => setTimeout(r, 80));
-		const released = lm.reapAndRelease();
-		expect(released).toContain("task-1");
-		expect(lm.get("task-1")).toBeNull();
-	});
-
-	it("isExpired returns false for fresh leases", () => {
-		const lm = new LeaseManager({ leasesDir: leasesDir() });
-		const lease = lm.claim("task-1", "worker-1");
-		expect(lm.isExpired(lease)).toBe(false);
-	});
-
-	it("isExpired returns true for expired leases", async () => {
-		const lm = new LeaseManager({ leasesDir: leasesDir(), leaseTtlMs: 1 });
-		lm.claim("task-1", "worker-1");
-		await new Promise((r) => setTimeout(r, 20));
-		expect(lm.isExpired(lm.get("task-1"))).toBe(true);
-	});
-
-	it("listActive returns only non-expired leases", async () => {
-		const lm = new LeaseManager({ leasesDir: leasesDir(), leaseTtlMs: 50 });
-		lm.claim("task-1", "worker-1");
-		await new Promise((r) => setTimeout(r, 80));
-		expect(lm.listActive()).toHaveLength(0);
-	});
-
-	it("recoverOnStartup releases orphan leases", async () => {
-		const lm = new LeaseManager({ leasesDir: leasesDir(), leaseTtlMs: 50 });
-		lm.claim("task-1", "worker-1");
-		await new Promise((r) => setTimeout(r, 80));
-		const released = lm.recoverOnStartup();
-		expect(released).toContain("task-1");
-	});
-});
-
-// ─── Storage paths ────────────────────────────────────────────────────────────
-
-describe("Storage paths", () => {
-	it("getInboxDir returns a path under the runtime root", async () => {
-		const { getRuntimeRoot, getInboxDir } = await import("../src/types.js");
-		expect(getInboxDir()).toContain(".pi/harness/inbox");
-		expect(getInboxDir()).toContain(getRuntimeRoot());
-	});
-
-	it("getLeasesDir returns claimed/ subdirectory", async () => {
-		const { getLeasesDir } = await import("../src/types.js");
-		expect(getLeasesDir()).toContain("claimed");
-	});
-});

package/packages/autonomous-runtime/test/inbox.test.ts

@@ -1,80 +0,0 @@
-/**
- * Tests for TaskInbox (filesystem-backed).
- */
-
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { mkdtempSync, rmSync, existsSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { TaskInbox } from "../src/inbox.js";
-
-const DIR = mkdtempSync(join(tmpdir(), "pi-inbox-test-"));
-
-// Set env so inbox uses our temp dir
-process.env.PI_HARNESS_RUNTIME_ROOT = DIR;
-
-const inbox = new TaskInbox({ rootDir: DIR });
-
-afterEach(async () => {
-	await inbox.clear?.();
-});
-
-afterAll(() => {
-	try { rmSync(DIR, { recursive: true }); } catch { /* ignore */ }
-});
-
-describe("TaskInbox.submit", () => {
-	it("accepts and returns a pending task", async () => {
-		const spec = {
-			id: "test-1",
-			kind: "once" as const,
-			priority: 5,
-			spec: {},
-		};
-		const record = await inbox.submit(spec);
-		expect(record.id).toBe("test-1");
-		expect(record.status).toBe("pending");
-		expect(record.submittedAt).toBeDefined();
-	});
-
-	it("rejects duplicate ids", async () => {
-		const spec = {
-			id: "dup-test",
-			kind: "once" as const,
-			priority: 5,
-			spec: {},
-		};
-		await inbox.submit(spec);
-		await expect(inbox.submit(spec)).rejects.toThrow();
-	});
-});
-
-describe("TaskInbox.list", () => {
-	it("returns all submitted tasks", async () => {
-		await inbox.submit({ id: "l1", kind: "once", priority: 1, spec: {} });
-		await inbox.submit({ id: "l2", kind: "once", priority: 2, spec: {} });
-		const records = await inbox.list();
-		expect(records.length).toBeGreaterThanOrEqual(2);
-	});
-
-	it("filters by status", async () => {
-		await inbox.submit({ id: "f1", kind: "once", priority: 1, spec: {} });
-		const pending = await inbox.list({ status: "pending" });
-		expect(pending.every((r) => r.status === "pending")).toBe(true);
-	});
-});
-
-describe("TaskInbox.claim", () => {
-	it("returns null when nothing is pending", async () => {
-		const lease = await inbox.claim({ workerId: "w1", heartbeatIntervalMs: 30_000 });
-		expect(lease).toBeNull();
-	});
-
-	it("returns a lease for a pending task", async () => {
-		await inbox.submit({ id: "claim-1", kind: "once", priority: 5, spec: {} });
-		const lease = await inbox.claim({ workerId: "w1", heartbeatIntervalMs: 30_000 });
-		expect(lease).not.toBeNull();
-		expect(lease!.taskId).toBe("claim-1");
-		expect(lease!.status).toBe("active");
-	});
-});

package/packages/autonomous-runtime/test/types.test.ts

@@ -1,68 +0,0 @@
-/**
- * Tests for autonomous-runtime types.
- */
-
-import { describe, it, expect } from "bun:test";
-import type {
-	TaskSpec,
-	TaskStatus,
-	TaskEvent,
-	TaskRecord,
-	LeaseStatus,
-	WorkerStatus,
-} from "../src/types.js";
-
-describe("TaskStatus enum", () => {
-	it("has all expected values", () => {
-		const values: TaskStatus[] = [
-			"pending",
-			"claimed",
-			"running",
-			"completed",
-			"failed",
-			"cancelled",
-		];
-		for (const v of values) {
-			expect(typeof v).toBe("string");
-		}
-	});
-});
-
-describe("LeaseStatus enum", () => {
-	it("has all expected values", () => {
-		const values: LeaseStatus[] = [
-			"active",
-			"renewed",
-			"released",
-			"expired",
-		];
-		for (const v of values) {
-			expect(typeof v).toBe("string");
-		}
-	});
-});
-
-describe("TaskSpec", () => {
-	it("accepts a minimal valid spec", () => {
-		const spec: TaskSpec = {
-			id: "task-1",
-			kind: "once",
-			priority: 5,
-			spec: {},
-		};
-		expect(spec.id).toBe("task-1");
-		expect(spec.kind).toBe("once");
-		expect(spec.priority).toBe(5);
-	});
-});
-
-describe("WorkerStatus", () => {
-	it("accepts a valid status", () => {
-		const status: WorkerStatus = {
-			workerId: "worker-1",
-			running: true,
-			heartbeatIntervalMs: 30_000,
-		};
-		expect(status.running).toBe(true);
-	});
-});

package/packages/autonomous-runtime/tsconfig.json

@@ -1,22 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ES2022",
-    "moduleResolution": "bundler",
-    "lib": ["ES2022", "DOM"],
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "composite": true,
-    "types": ["node"]
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "test"]
-}