oh-my-opencode 5.0.0-beta.6 → 5.0.0-beta.62

package/packages/omo-codex/plugin/components/ulw-loop/test/sdk-driver-states.test.ts

@@ -0,0 +1,145 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+
+import { readUlwLoopPlan } from "../src/plan-io.js";
+import { createAgentToolkit } from "../src/sdk.js";
+
+const workDirs: string[] = [];
+
+afterEach(async () => {
+	for (const dir of workDirs.splice(0)) await rm(dir, { recursive: true, force: true });
+});
+
+interface Seeded {
+	readonly cwd: string;
+	readonly sessionId: string;
+	readonly goalId: string;
+	readonly objective: string;
+}
+
+// One fixture shape for every driver state: a real plan whose first goal is ready to close, so the
+// only thing under test is what the driver snapshot does to the checkpoint.
+async function seed(sessionId: string): Promise<Seeded> {
+	const cwd = await mkdtemp(join(tmpdir(), "ulw-driver-"));
+	workDirs.push(cwd);
+	const toolkit = createAgentToolkit({ cwd, sessionId, surface: "omo-senpi" });
+	const created = await toolkit.createGoals({ brief: "- alpha goal\n- beta goal" });
+	if (!created.ok) throw new Error("fixture could not create goals");
+	const started = await toolkit.completeGoals({});
+	if (!started.ok || started.operation !== "complete-goals" || "done" in started.result)
+		throw new Error("fixture could not start a goal");
+	const goalId = started.result.goal.id;
+	const criteria = await toolkit.criteria({ goalId });
+	if (!criteria.ok || criteria.operation !== "criteria") throw new Error("fixture has no criteria");
+	for (const criterion of criteria.result.criteria) {
+		const recorded = await toolkit.recordEvidence({
+			goalId,
+			criterionId: criterion.id,
+			status: "pass",
+			evidence: "driver-state fixture proof",
+		});
+		if (!recorded.ok) throw new Error("fixture could not record evidence");
+	}
+	const plan = await readUlwLoopPlan(cwd, { sessionId });
+	return { cwd, sessionId, goalId, objective: plan.codexObjective ?? "" };
+}
+
+async function closeWith(seeded: Seeded, snapshot?: Record<string, unknown>) {
+	const toolkit = createAgentToolkit({ cwd: seeded.cwd, sessionId: seeded.sessionId, surface: "omo-senpi" });
+	return toolkit.checkpoint({
+		goalId: seeded.goalId,
+		status: "complete",
+		evidence: "driver-state checkpoint",
+		...(snapshot === undefined ? {} : { codexGoalJson: JSON.stringify(snapshot) }),
+	});
+}
+
+describe("SDK driver-goal states", () => {
+	describe("#given no driver snapshot", () => {
+		it("#when the goal is checkpointed #then it completes and advises creating the driver goal", async () => {
+			const seeded = await seed("driver-absent");
+
+			const closed = await closeWith(seeded);
+
+			expect(closed.ok).toBe(true);
+			if (closed.ok) expect(closed.nextActions.join(" ")).toContain("create_goal");
+		});
+	});
+
+	describe("#given an active driver carrying the plan objective", () => {
+		it("#when the goal is checkpointed #then it completes with no objective difference reported", async () => {
+			const seeded = await seed("driver-active");
+
+			const closed = await closeWith(seeded, { goal: { objective: seeded.objective, status: "active" } });
+
+			expect(closed.ok).toBe(true);
+			if (closed.ok) {
+				expect([...(closed.warnings ?? []), ...closed.nextActions].join(" ")).not.toContain(
+					"driver_objective_differs",
+				);
+			}
+		});
+	});
+
+	describe("#given a driver completed before the plan finished", () => {
+		it("#when the goal is checkpointed #then it completes and advises re-creating the driver", async () => {
+			const seeded = await seed("driver-early");
+
+			const closed = await closeWith(seeded, { goal: { objective: seeded.objective, status: "complete" } });
+
+			expect(closed.ok).toBe(true);
+			if (closed.ok) expect(closed.nextActions.join(" ")).toContain("create_goal");
+		});
+	});
+
+	describe("#given a driver the harness has limited", () => {
+		for (const status of ["paused", "usage_limited", "budget_limited"] as const) {
+			it(`#when the driver is ${status} #then the checkpoint still completes and advises resuming it`, async () => {
+				const seeded = await seed(`driver-${status}`);
+
+				const closed = await closeWith(seeded, { goal: { objective: seeded.objective, status } });
+
+				expect(closed.ok).toBe(true);
+				if (closed.ok) expect(closed.nextActions.join(" ")).toContain("/goal resume");
+			});
+		}
+	});
+
+	describe("#given a driver whose objective differs from the plan", () => {
+		it("#when the goal is checkpointed #then the difference is reported, never a rejection", async () => {
+			const seeded = await seed("driver-differs");
+
+			const closed = await closeWith(seeded, { goal: { objective: "a different objective", status: "active" } });
+
+			expect(closed.ok).toBe(true);
+			if (closed.ok) {
+				expect([...(closed.warnings ?? []), ...closed.nextActions].join(" ")).toContain("driver_objective_differs");
+			}
+		});
+	});
+
+	describe("#given snapshot input that is neither JSON nor a readable path", () => {
+		it("#when the goal is checkpointed #then the typed error is returned and the goal stays open", async () => {
+			const seeded = await seed("driver-malformed");
+
+			const closed = await closeWith(seeded);
+			expect(closed.ok).toBe(true);
+
+			const second = await seed("driver-malformed-2");
+			const toolkit = createAgentToolkit({ cwd: second.cwd, sessionId: second.sessionId, surface: "omo-senpi" });
+			const rejected = await toolkit.checkpoint({
+				goalId: second.goalId,
+				status: "complete",
+				evidence: "driver-state checkpoint",
+				codexGoalJson: "not json and not a path",
+			});
+
+			expect(rejected.ok).toBe(false);
+			if (!rejected.ok) expect(rejected.error.code).toBe("ULW_LOOP_CODEX_GOAL_JSON_INVALID");
+			const plan = await readUlwLoopPlan(second.cwd, { sessionId: second.sessionId });
+			expect(plan.goals.find((goal) => goal.id === second.goalId)?.status).not.toBe("complete");
+		});
+	});
+});

package/packages/omo-codex/plugin/components/ulw-loop/test/sdk-session-context.test.ts

@@ -0,0 +1,148 @@
+import { type ChildProcess, spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+
+import { ulwLoopLedgerPath, ulwLoopStateLockPath } from "../src/paths.js";
+import { createAgentToolkit } from "../src/sdk.js";
+
+const children: ChildProcess[] = [];
+const workDirs: string[] = [];
+
+afterEach(async () => {
+	for (const child of children.splice(0)) {
+		if (child.exitCode === null) child.kill("SIGKILL");
+	}
+	for (const dir of workDirs.splice(0)) await rm(dir, { recursive: true, force: true });
+});
+
+const HOLDER_SCRIPT = `
+const fs = require("node:fs");
+const path = require("node:path");
+const [lockPath, holdMs] = process.argv.slice(1);
+fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+const fd = fs.openSync(lockPath, "wx");
+fs.writeSync(fd, JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString(), token: "holder-" + process.pid }));
+fs.closeSync(fd);
+process.stdout.write("HELD\\n");
+setTimeout(() => {
+	fs.writeFileSync(lockPath + ".released", "");
+	fs.unlinkSync(lockPath);
+}, Number(holdMs));
+`;
+
+async function makeWorkdir(): Promise<string> {
+	const dir = await mkdtemp(join(tmpdir(), "ulw-sdk-session-"));
+	workDirs.push(dir);
+	return dir;
+}
+
+function holdStateLock(lockPath: string, holdMs: number): Promise<{ readonly releasedMarker: string }> {
+	return new Promise((resolve, reject) => {
+		const child = spawn(process.execPath, ["-e", HOLDER_SCRIPT, lockPath, String(holdMs)], {
+			stdio: ["ignore", "pipe", "inherit"],
+		});
+		children.push(child);
+		let output = "";
+		child.stdout.setEncoding("utf8");
+		child.stdout.on("data", (chunk: string) => {
+			output += chunk;
+			if (output.includes("HELD")) resolve({ releasedMarker: `${lockPath}.released` });
+		});
+		child.once("error", reject);
+	});
+}
+
+async function seedSession(
+	cwd: string,
+	sessionId: string,
+): Promise<{ readonly goalId: string; readonly criteria: readonly string[] }> {
+	const toolkit = createAgentToolkit({ cwd, sessionId, surface: "lazycodex" });
+	const created = await toolkit.createGoals({ brief: "Session context fixture" });
+	if (!created.ok) throw new Error("fixture could not create goals");
+	const started = await toolkit.completeGoals({});
+	if (!started.ok || started.operation !== "complete-goals" || "done" in started.result)
+		throw new Error("fixture could not start a goal");
+	const goalId = started.result.goal.id;
+	const criteria = await toolkit.criteria({ goalId });
+	if (!criteria.ok || criteria.operation !== "criteria") throw new Error("fixture has no criteria");
+	return { goalId, criteria: criteria.result.criteria.map((criterion) => criterion.id) };
+}
+
+describe("agent toolkit session context", () => {
+	describe("#given a plan written under session A", () => {
+		it("#when session B reads through its own context #then the read fails closed instead of borrowing A", async () => {
+			const cwd = await makeWorkdir();
+			await seedSession(cwd, "session-a");
+
+			const foreign = createAgentToolkit({ cwd, sessionId: "session-b", surface: "lazycodex" });
+			const status = await foreign.status();
+
+			expect(status.ok).toBe(false);
+		});
+	});
+
+	describe("#given the session state lock held by another process", () => {
+		it("#when an SDK mutation runs #then it waits for that release before writing", async () => {
+			const cwd = await makeWorkdir();
+			const sessionId = "session-lock";
+			const seeded = await seedSession(cwd, sessionId);
+			const criterionId = seeded.criteria[0];
+			if (criterionId === undefined) throw new Error("fixture has no criterion");
+			const holder = await holdStateLock(ulwLoopStateLockPath(cwd, { sessionId }), 300);
+
+			const toolkit = createAgentToolkit({ cwd, sessionId, surface: "lazycodex" });
+			const recorded = await toolkit.recordEvidence({
+				goalId: seeded.goalId,
+				criterionId,
+				status: "pass",
+				evidence: "waited for the held lock",
+			});
+
+			expect(recorded.ok).toBe(true);
+			expect(existsSync(holder.releasedMarker)).toBe(true);
+		});
+	});
+
+	describe("#given two SDK instances bound to one session directory", () => {
+		it("#when both record evidence concurrently #then the ledger keeps both entries", async () => {
+			const cwd = await makeWorkdir();
+			const sessionId = "session-concurrent";
+			const seeded = await seedSession(cwd, sessionId);
+			const first = seeded.criteria[0];
+			const second = seeded.criteria[1];
+			if (first === undefined || second === undefined) throw new Error("fixture needs two criteria");
+
+			const results = await Promise.all([
+				createAgentToolkit({ cwd, sessionId, surface: "lazycodex" }).recordEvidence({
+					goalId: seeded.goalId,
+					criterionId: first,
+					status: "pass",
+					evidence: "first instance",
+				}),
+				createAgentToolkit({ cwd, sessionId, surface: "lazycodex" }).recordEvidence({
+					goalId: seeded.goalId,
+					criterionId: second,
+					status: "pass",
+					evidence: "second instance",
+				}),
+			]);
+
+			expect(results.every((result) => result.ok)).toBe(true);
+			const ledger = await readFile(ulwLoopLedgerPath(cwd, { sessionId }), "utf8");
+			const recorded = ledger
+				.split("\n")
+				.filter((line) => line.trim().length > 0)
+				.map((line): unknown => JSON.parse(line))
+				.filter((entry): entry is { readonly criterionId: string } => {
+					if (typeof entry !== "object" || entry === null || !("criterionId" in entry)) return false;
+					return typeof entry.criterionId === "string";
+				})
+				.map((entry) => entry.criterionId);
+			expect(recorded).toContain(first);
+			expect(recorded).toContain(second);
+		});
+	});
+});