pi-harness-runtime 0.9.15 → 0.9.17

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

@@ -0,0 +1,194 @@
+/**
+ * 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

@@ -0,0 +1,266 @@
+/**
+ * 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

@@ -0,0 +1,80 @@
+/**
+ * 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

@@ -0,0 +1,68 @@
+/**
+ * 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

@@ -0,0 +1,22 @@
+{
+  "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"]
+}