pi-harness-runtime 1.1.440 → 1.1.442

package/harness/langchain/checkpointer.test.ts

@@ -1,243 +0,0 @@
-/**
- * FileCheckpointSaver tests — T9–T11 (wiki/auto-trigger-multi-agent.md §M5)
- *
- * Run:
- *   bun test harness/langchain/checkpointer.test.ts
- */
-
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import { existsSync, mkdirSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { randomUUID } from "node:crypto";
-
-import { FileCheckpointSaver, createLoopCheckpointer } from "./checkpointer.js";
-
-// ─── Fixtures ────────────────────────────────────────────────────────────────
-
-const ROOT = `/tmp/checkpointer-test-${randomUUID().slice(0, 8)}`;
-
-function freshSaver(): FileCheckpointSaver {
-	const saver = new FileCheckpointSaver({ root: ROOT });
-	saver.clearAll();
-	return saver;
-}
-
-const THREAD = "thread-abc123";
-const CONFIG = { configurable: { thread_id: THREAD } };
-const CONFIG_WITH_CPID = {
-	configurable: { thread_id: THREAD, checkpoint_id: "cp-001" },
-};
-
-// ─── T9: Basic put/get ──────────────────────────────────────────────────────
-
-describe("T9 — put and get basic checkpoint", () => {
-	it("stores and retrieves a checkpoint", async () => {
-		const saver = freshSaver();
-
-		const checkpoint = {
-			v: 4,
-			id: "cp-001",
-			ts: "2026-08-31T10:00:00.000Z",
-			channel_values: { plan: "do the thing", code: "" },
-			channel_versions: { plan: 1, code: 0 },
-			versions_seen: {},
-		};
-		const metadata = {
-			source: "input" as const,
-			step: -1,
-			parents: {},
-		};
-
-		const updatedConfig = await saver.put(CONFIG, checkpoint, metadata, {});
-		assert.equal(updatedConfig.configurable?.checkpoint_id, "cp-001");
-
-		// Retrieve it
-		const tuple = await saver.getTuple(CONFIG_WITH_CPID);
-		assert.ok(tuple, "should retrieve the checkpoint");
-		assert.equal(tuple?.checkpoint.id, "cp-001");
-		assert.equal(
-			(tuple?.checkpoint.channel_values as Record<string, unknown>)?.plan,
-			"do the thing",
-		);
-	});
-
-	it("get() returns the checkpoint", async () => {
-		const saver = freshSaver();
-		const cp = {
-			v: 4,
-			id: "cp-get",
-			ts: "2026-08-31T10:01:00.000Z",
-			channel_values: { plan: "test plan" },
-			channel_versions: {},
-			versions_seen: {},
-		};
-		await saver.put(CONFIG, cp, { source: "input", step: -1, parents: {} }, {});
-
-		const retrieved = await saver.get({
-			configurable: { thread_id: THREAD, checkpoint_id: "cp-get" },
-		});
-		assert.ok(retrieved, "should return the checkpoint");
-		assert.equal(retrieved?.id, "cp-get");
-	});
-});
-
-// ─── T10: Parent chain ──────────────────────────────────────────────────────
-
-describe("T10 — parent chain", () => {
-	it("stores and retrieves a parent chain (resume)", async () => {
-		const saver = freshSaver();
-
-		const root = {
-			v: 4,
-			id: "root",
-			ts: "2026-08-31T10:00:00.000Z",
-			channel_values: {},
-			channel_versions: {},
-			versions_seen: {},
-		};
-		const child = {
-			v: 4,
-			id: "child",
-			ts: "2026-08-31T10:01:00.000Z",
-			channel_values: { plan: "the plan" },
-			channel_versions: { plan: 1 },
-			versions_seen: {},
-		};
-
-		await saver.put(CONFIG, root, { source: "input", step: -1, parents: {} }, {});
-		await saver.put(
-			CONFIG,
-			child,
-			{ source: "loop", step: 0, parents: { "": "root" } },
-			{},
-		);
-
-		// Retrieve child and verify parent
-		const tuple = await saver.getTuple({
-			configurable: { thread_id: THREAD, checkpoint_id: "child" },
-		});
-		assert.ok(tuple);
-		assert.ok(tuple?.parentConfig);
-		assert.equal(tuple?.parentConfig?.configurable?.checkpoint_id, "root");
-
-		// getTuple without checkpoint_id returns the latest
-		const latest = await saver.getTuple(CONFIG);
-		assert.ok(latest);
-		assert.equal(latest?.checkpoint.id, "child");
-	});
-});
-
-// ─── T11: list + deleteThread ───────────────────────────────────────────────
-
-describe("T11 — list and deleteThread", () => {
-	it("lists checkpoints in reverse chronological order", async () => {
-		const saver = freshSaver();
-
-		for (let i = 0; i < 5; i++) {
-			const cp = {
-				v: 4,
-				id: `cp-${i}`,
-				ts: new Date(1000 + i * 1000).toISOString(),
-				channel_values: { step: i },
-				channel_versions: {},
-				versions_seen: {},
-			};
-			await saver.put(CONFIG, cp, { source: "loop", step: i, parents: {} }, {});
-		}
-
-		const all: string[] = [];
-		for await (const tuple of saver.list(CONFIG)) {
-			all.push(tuple.checkpoint.id);
-		}
-		assert.equal(all.length, 5);
-		// Newest first
-		assert.equal(all[0], "cp-4");
-		assert.equal(all[4], "cp-0");
-	});
-
-	it("limits list results", async () => {
-		const saver = freshSaver();
-		for (let i = 0; i < 3; i++) {
-			const cp = {
-				v: 4,
-				id: `limit-${i}`,
-				ts: new Date(2000 + i * 1000).toISOString(),
-				channel_values: {},
-				channel_versions: {},
-				versions_seen: {},
-			};
-			await saver.put(CONFIG, cp, { source: "loop", step: i, parents: {} }, {});
-		}
-
-		const limited: string[] = [];
-		for await (const tuple of saver.list(CONFIG, { limit: 2 })) {
-			limited.push(tuple.checkpoint.id);
-		}
-		assert.equal(limited.length, 2);
-	});
-
-	it("deleteThread removes all checkpoints for a thread", async () => {
-		const saver = freshSaver();
-
-		const cp = {
-			v: 4,
-			id: "delete-me",
-			ts: "2026-08-31T12:00:00.000Z",
-			channel_values: {},
-			channel_versions: {},
-			versions_seen: {},
-		};
-		await saver.put(CONFIG, cp, { source: "input", step: -1, parents: {} }, {});
-
-		assert.ok(await saver.getTuple(CONFIG), "checkpoint should exist");
-
-		await saver.deleteThread(THREAD);
-
-		assert.ok(
-			!(await saver.getTuple(CONFIG)),
-			"checkpoint should be gone after deleteThread",
-		);
-	});
-
-	it("toJSON returns a string (not the internal object)", async () => {
-		const saver = freshSaver();
-		const json = saver.toJSON();
-		assert.equal(typeof json, "string");
-		assert.ok(json.length > 0);
-	});
-
-	it("listThreads returns thread ids", async () => {
-		const saver = freshSaver();
-		const tid = `thread-${randomUUID().slice(0, 6)}`;
-		const cp = {
-			v: 4,
-			id: "cp-t",
-			ts: "2026-08-31T12:00:00.000Z",
-			channel_values: {},
-			channel_versions: {},
-			versions_seen: {},
-		};
-		await saver.put(
-			{ configurable: { thread_id: tid } },
-			cp,
-			{ source: "input", step: -1, parents: {} },
-			{},
-		);
-
-		const threads = saver.listThreads();
-		assert.ok(
-			threads.includes(tid),
-			`Expected ${tid} in ${JSON.stringify(threads)}`,
-		);
-	});
-});
-
-// ─── T12: createLoopCheckpointer factory ─────────────────────────────────────
-
-describe("T12 — createLoopCheckpointer factory", () => {
-	it("creates a saver with the correct root path", () => {
-		const saver = createLoopCheckpointer("/my/workspace");
-		assert.ok(saver instanceof FileCheckpointSaver);
-	});
-});

package/harness/langchain/daemon.test.ts

@@ -1,459 +0,0 @@
-/**
- * Daemon Acceptance Tests (T1–T7)
- *
- * All tests run with dryRun=true — no API keys needed.
- * Tests write inbox files to /tmp/herdr-workspace (the real workspace the daemon watches).
- *
- * Run:
- *   bun test harness/langchain/daemon.test.ts
- */
-
-import { before, describe, it } from "node:test";
-import assert from "node:assert";
-import {
-	existsSync,
-	mkdirSync,
-	readFileSync,
-	readdirSync,
-	rmSync,
-	writeFileSync,
-} from "node:fs";
-import { join } from "node:path";
-import { randomUUID } from "node:crypto";
-
-import { LoopDaemon, writeAck } from "./daemon.js";
-import type { DaemonConfig } from "./daemon.js";
-import type { LoopDeps } from "./graph.js";
-
-// ─── Test fixtures ────────────────────────────────────────────────────────────
-
-const WORKSPACE = "/tmp/herdr-workspace";
-
-/** Replicate the daemon's stableTaskId() logic so tests can write matching ack files. */
-function daemonTaskId(source: string, raw: string): string {
-	if (source === "inbox") return raw;
-	const base = `${source}:${raw}`.slice(0, 64);
-	let hash = 0;
-	for (let i = 0; i < base.length; i++) {
-		const ch = base.charCodeAt(i);
-		hash = (hash << 5) - hash + ch;
-		hash |= 0;
-	}
-	return `task-${Math.abs(hash).toString(36)}-${Date.now().toString(36).slice(-6)}`;
-}
-
-function testConfig(overrides: Partial<DaemonConfig> = {}): DaemonConfig {
-	return {
-		agentId: `test-daemon-${randomUUID().slice(0, 6)}`,
-		pollMs: 100,
-		maxIterations: 3,
-		approvalPolicy: "never",
-		dryRun: true,
-		sources: ["inbox", "bus"],
-		...overrides,
-	} as DaemonConfig;
-}
-
-async function waitFor(
-	fn: () => boolean,
-	timeoutMs = 5000,
-	intervalMs = 50,
-): Promise<void> {
-	const deadline = Date.now() + timeoutMs;
-	while (Date.now() < deadline) {
-		if (fn()) return;
-		await new Promise((r) => setTimeout(r, intervalMs));
-	}
-	throw new Error(`waitFor timed out after ${timeoutMs}ms`);
-}
-
-function readEvents(): string[] {
-	const path = join(WORKSPACE, "events.jsonl");
-	if (!existsSync(path)) return [];
-	return readFileSync(path, "utf8")
-		.split("\n")
-		.filter((l) => l.trim())
-		.map((l) => {
-			try {
-				return (JSON.parse(l) as { topic?: string }).topic ?? "";
-			} catch {
-				return "";
-			}
-		})
-		.filter(Boolean);
-}
-
-async function waitForEvent(topic: string, timeoutMs = 8000): Promise<void> {
-	await waitFor(() => readEvents().includes(topic), timeoutMs);
-}
-
-function countEvents(topic: string): number {
-	return readEvents().filter((t) => t === topic).length;
-}
-
-function cleanEvents(): void {
-	const path = join(WORKSPACE, "events.jsonl");
-	if (existsSync(path)) rmSync(path, { force: true });
-	// Also clean ack files so they don't interfere with subsequent tests
-	for (const file of readdirSync(WORKSPACE)) {
-		if (file.startsWith("ack-")) {
-			try {
-				rmSync(join(WORKSPACE, file), { force: true });
-			} catch {
-				/* ignore */
-			}
-		}
-	}
-}
-
-// ─── Setup ──────────────────────────────────────────────────────────────────
-
-before(() => {
-	if (!existsSync(WORKSPACE)) mkdirSync(WORKSPACE, { recursive: true });
-});
-
-// ─── T1: Inbox file drop ─────────────────────────────────────────────────────
-
-describe("T1 — inbox file drop triggers loop", () => {
-	it("loop.started / code.written / review.completed / loop.finished appear", async () => {
-		cleanEvents();
-		const daemon = new LoopDaemon(testConfig({ sources: ["inbox"] }));
-		daemon.start();
-		try {
-			const filename = `test-T1-${randomUUID().slice(0, 6)}.md`;
-			writeFileSync(
-				join(WORKSPACE, filename),
-				"Implement a greeting function",
-				"utf8",
-			);
-			await waitForEvent("loop.finished", 15_000);
-			const events = readEvents();
-			assert(
-				events.includes("loop.started"),
-				`Missing loop.started: ${JSON.stringify(events)}`,
-			);
-			assert(
-				events.includes("code.written"),
-				`Missing code.written: ${JSON.stringify(events)}`,
-			);
-			assert(
-				events.includes("review.completed"),
-				`Missing review.completed: ${JSON.stringify(events)}`,
-			);
-			assert(
-				events.includes("loop.finished"),
-				`Missing loop.finished: ${JSON.stringify(events)}`,
-			);
-		} finally {
-			daemon.stop();
-		}
-	});
-});
-
-// ─── T2: Bus task.proposed event ─────────────────────────────────────────────
-
-describe("T2 — bus task.proposed event triggers loop", () => {
-	it("loop.finished appears after publishing task.proposed", async () => {
-		cleanEvents();
-		const daemon = new LoopDaemon(testConfig({ sources: ["bus"] }));
-		daemon.start();
-		try {
-			writeFileSync(
-				join(WORKSPACE, "events.jsonl"),
-				JSON.stringify({
-					eventId: randomUUID(),
-					topic: "task.proposed",
-					data: { taskId: "T2-task", request: "Add a rate limiter" },
-					ts: new Date().toISOString(),
-				}) + "\n",
-				{ flag: "a" },
-			);
-			await waitForEvent("loop.finished", 15_000);
-			assert(
-				countEvents("loop.finished") >= 1,
-				"Expected at least one loop.finished",
-			);
-		} finally {
-			daemon.stop();
-		}
-	});
-});
-
-// ─── T3: No-human proof ─────────────────────────────────────────────────────
-
-describe("T3 — no-human proof (approvalPolicy=never)", () => {
-	it("loop completes without any ack file being created", async () => {
-		cleanEvents();
-		const daemon = new LoopDaemon(
-			testConfig({ sources: ["inbox"], approvalPolicy: "never" }),
-		);
-		daemon.start();
-		try {
-			const filename = `test-T3-${randomUUID().slice(0, 6)}.md`;
-			writeFileSync(join(WORKSPACE, filename), "Write a utility", "utf8");
-			await waitForEvent("loop.finished", 15_000);
-			const ackFiles = readdirSync(WORKSPACE).filter((f) => f.startsWith("ack-"));
-			assert.strictEqual(
-				ackFiles.length,
-				0,
-				`Unexpected ack files: ${ackFiles.join(", ")}`,
-			);
-		} finally {
-			daemon.stop();
-		}
-	});
-});
-
-// ─── T4: Approval gate ──────────────────────────────────────────────────────
-
-describe("T4 — approval gate", () => {
-	it("parks when approvalPolicy=always and resumes after ack", async () => {
-		cleanEvents();
-		const filename = `test-T4a-${randomUUID().slice(0, 6)}.md`;
-		const daemon = new LoopDaemon(
-			testConfig({
-				sources: ["inbox"],
-				approvalPolicy: "always",
-				maxIterations: 1,
-			}),
-		);
-		daemon.start();
-		try {
-			writeFileSync(join(WORKSPACE, filename), "Test gate always", "utf8");
-			// Daemon should wait for ack — no loop.started yet
-			await new Promise((r) => setTimeout(r, 500));
-			assert.strictEqual(
-				countEvents("loop.started"),
-				0,
-				"loop.started should not appear before ack",
-			);
-
-			// Write ack using daemon's computed taskId
-			const taskId = daemonTaskId("inbox", filename);
-			writeAck(WORKSPACE, taskId, "approved");
-			await waitForEvent("loop.finished", 15_000);
-		} finally {
-			daemon.stop();
-		}
-	});
-
-	it("task is skipped when ack is denied", async () => {
-		cleanEvents();
-		const filename = `test-T4b-${randomUUID().slice(0, 6)}.md`;
-		const daemon = new LoopDaemon(
-			testConfig({
-				sources: ["inbox"],
-				approvalPolicy: "always",
-				maxIterations: 1,
-			}),
-		);
-		daemon.start();
-		try {
-			writeFileSync(join(WORKSPACE, filename), "Test gate deny", "utf8");
-			await new Promise((r) => setTimeout(r, 500));
-			const taskId = daemonTaskId("inbox", filename);
-			writeAck(WORKSPACE, taskId, "denied");
-			await new Promise((r) => setTimeout(r, 500));
-			assert.strictEqual(
-				countEvents("loop.started"),
-				0,
-				"No loop should start after denied ack",
-			);
-		} finally {
-			daemon.stop();
-		}
-	});
-});
-
-// ─── T5: Single-writer ──────────────────────────────────────────────────────
-
-describe("T5 — single-writer (exactly one lease winner)", () => {
-	it("two daemons: only one processes the task", async () => {
-		cleanEvents();
-		const daemon1 = new LoopDaemon(
-			testConfig({ agentId: "daemon-A", sources: ["inbox"] }),
-		);
-		const daemon2 = new LoopDaemon(
-			testConfig({ agentId: "daemon-B", sources: ["inbox"] }),
-		);
-		daemon1.start();
-		daemon2.start();
-		try {
-			const filename = `test-T5-${randomUUID().slice(0, 6)}.md`;
-			writeFileSync(join(WORKSPACE, filename), "Shared task", "utf8");
-			await waitForEvent("loop.finished", 15_000);
-			// Both daemons will see the file. LeaseManager ensures only one wins.
-			// With two daemons, we expect exactly 1 loop.finished.
-			// (Both may process it in theory if they race, but the lease prevents this.)
-			const finishedCount = countEvents("loop.finished");
-			assert.ok(
-				finishedCount >= 1,
-				`Expected at least 1 loop.finished, got ${finishedCount}`,
-			);
-		} finally {
-			daemon1.stop();
-			daemon2.stop();
-		}
-	});
-});
-
-// ─── T6: maxIterations cap ─────────────────────────────────────────────────
-
-describe("T6 — maxIterations cap", () => {
-	it("with maxIterations=2, exactly 2 code.written events appear", async () => {
-		cleanEvents();
-		// Mock reviewer: always changes_requested with a rotating file to avoid smart-stop.
-		// Use a mutable ref so review() sees the CURRENT writeCount (after increment).
-		const counter = { n: 0 };
-		const mockDeps: LoopDeps = {
-			maxIterations: 2,
-			onStep: undefined,
-			plan: async () => "# Stub plan\n1. Do thing",
-			write: async () => {
-				counter.n++;
-				return `// code pass ${counter.n}`;
-			},
-			review: async () => ({
-				verdict: "changes_requested" as const,
-				summary: "need changes",
-				comments: [
-					{ file: `file${counter.n}.ts`, comment: "fix this", severity: "major" },
-				],
-			}),
-		};
-		const daemon = new LoopDaemon(
-			testConfig({ sources: ["inbox"], maxIterations: 2, deps: mockDeps }),
-		);
-		daemon.start();
-		try {
-			const filename = `test-T6-${randomUUID().slice(0, 6)}.md`;
-			writeFileSync(join(WORKSPACE, filename), "Test iteration cap", "utf8");
-			await waitForEvent("loop.finished", 15_000);
-			// Mock: writeCount=1 → review(changes, file1.ts) → writeCount=2 → review(changes, file2.ts)
-			// With maxIterations=2, the hard cap kicks in after iteration 2 → loop exits
-			// Smart-stop: different files (file1 vs file2) → no stuck-file trigger
-			assert.strictEqual(
-				counter.n,
-				2,
-				`Expected exactly 2 writes (maxIterations=2, smart-stop overridden by different files)`,
-			);
-		} finally {
-			daemon.stop();
-		}
-	});
-
-	it("smart-stop: converged (only minor comments) terminates early", async () => {
-		cleanEvents();
-		let writeCount = 0;
-		// Reviewer returns only minor comments → smart-stop should trigger at iteration 1
-		const mockDeps: LoopDeps = {
-			maxIterations: 5,
-			onStep: undefined,
-			plan: async () => "# Stub plan",
-			write: async () => {
-				writeCount++;
-				return `// code ${writeCount}`;
-			},
-			review: async () => ({
-				verdict: "changes_requested" as const,
-				summary: "minor",
-				comments: [
-					{ file: "a.ts", comment: "nitpick", severity: "minor" },
-					{ file: "b.ts", comment: "typo", severity: "minor" },
-				],
-			}),
-		};
-		const daemon = new LoopDaemon(
-			testConfig({ sources: ["inbox"], maxIterations: 5, deps: mockDeps }),
-		);
-		daemon.start();
-		try {
-			const filename = `test-T6b-${randomUUID().slice(0, 6)}.md`;
-			writeFileSync(join(WORKSPACE, filename), "Test smart-stop", "utf8");
-			await waitForEvent("loop.finished", 15_000);
-			// Smart-stop: hasOnlyMinor=true (2 minor comments) → stop at iteration 1
-			assert.strictEqual(writeCount, 1, "converged: should stop after 1 write");
-		} finally {
-			daemon.stop();
-		}
-	});
-});
-
-// ─── T7: Crash resilience ───────────────────────────────────────────────────
-
-describe("T7 — crash resilience", () => {
-	it("daemon restart processes pending tasks", async () => {
-		cleanEvents();
-		const daemon1 = new LoopDaemon(testConfig({ sources: ["inbox"] }));
-		daemon1.start();
-		try {
-			const filename = `test-T7-${randomUUID().slice(0, 6)}.md`;
-			writeFileSync(join(WORKSPACE, filename), "Restart test", "utf8");
-			await new Promise((r) => setTimeout(r, 500));
-		} finally {
-			daemon1.stop();
-		}
-
-		// Simulate restart — new daemon picks up the task
-		const daemon2 = new LoopDaemon(testConfig({ sources: ["inbox"] }));
-		daemon2.start();
-		try {
-			await waitForEvent("loop.finished", 15_000);
-			assert.ok(
-				countEvents("loop.finished") >= 1,
-				"Expected loop.finished after restart",
-			);
-		} finally {
-			daemon2.stop();
-		}
-	});
-});
-
-// ─── T13: Persistent checkpointer (M5) ──────────────────────────────────────
-
-describe("T13 — persistent checkpointer (M5)", () => {
-	it("loop checkpoints survive daemon stop and resume from last checkpoint", async () => {
-		cleanEvents();
-		// Use persistent checkpointer (true = use workspace root for checkpoints)
-		const daemon1 = new LoopDaemon(
-			testConfig({ sources: ["inbox"], checkpointer: true }),
-		);
-		daemon1.start();
-
-		const filename = `test-T13-${randomUUID().slice(0, 6)}.md`;
-		writeFileSync(
-			join(WORKSPACE, filename),
-			"Persistent checkpoint test",
-			"utf8",
-		);
-
-		// Let the loop run for one iteration
-		await new Promise((r) => setTimeout(r, 500));
-		daemon1.stop();
-
-		// Verify checkpoints exist on disk
-		const { createLoopCheckpointer } = await import("./checkpointer.js");
-		const saver = createLoopCheckpointer(WORKSPACE);
-		const threads = saver.listThreads();
-		assert.ok(
-			threads.length > 0,
-			`Expected checkpoint threads, got: ${JSON.stringify(threads)}`,
-		);
-
-		// Resume with new daemon — should pick up from checkpoint
-		const daemon2 = new LoopDaemon(
-			testConfig({ sources: ["inbox"], checkpointer: true }),
-		);
-		daemon2.start();
-		try {
-			await waitForEvent("loop.finished", 15_000);
-			assert.ok(
-				countEvents("loop.finished") >= 1,
-				"Expected loop.finished after resume",
-			);
-		} finally {
-			daemon2.stop();
-			saver.clearAll();
-		}
-	});
-});