oh-my-opencode 4.5.1 → 4.5.12

package/packages/omo-codex/plugin/components/ulw-loop/test/review-blockers.test.ts

@@ -0,0 +1,180 @@
+import { mkdir, mkdtemp, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+
+import { ULW_LOOP_AGGREGATE_CODEX_OBJECTIVE } from "../src/goal-status.js";
+import { ulwLoopDir, ulwLoopLedgerPath } from "../src/paths.js";
+import { writePlan } from "../src/plan-io.js";
+import { recordFinalReviewBlockers } from "../src/review-blockers.js";
+import type { UlwLoopItem, UlwLoopPlan, UlwLoopSuccessCriterion } from "../src/types.js";
+import { UlwLoopError } from "../src/types.js";
+
+const NOW = "2026-05-23T00:00:00.000Z";
+const VALID_SNAPSHOT_JSON = JSON.stringify({
+	goal: { objective: ULW_LOOP_AGGREGATE_CODEX_OBJECTIVE, status: "active" },
+});
+
+const validArgs = {
+	goalId: "G002",
+	title: "Resolve final code-review blockers",
+	objective: "Address the BLOCK findings from the architect",
+	evidence: "review verdict: REQUEST_CHANGES (3 issues)",
+	codexGoalJson: VALID_SNAPSHOT_JSON,
+};
+
+function makeCriterion(overrides: Partial<UlwLoopSuccessCriterion> = {}): UlwLoopSuccessCriterion {
+	return {
+		id: "C001",
+		scenario: "happy path",
+		userModel: "happy",
+		expectedEvidence: "observable proof",
+		capturedEvidence: null,
+		status: "pending",
+		...overrides,
+	};
+}
+
+function makeGoal(overrides: Partial<UlwLoopItem> = {}): UlwLoopItem {
+	return {
+		id: "G001",
+		title: "Build durable plan",
+		objective: "Complete one ulw-loop story",
+		status: "pending",
+		successCriteria: [makeCriterion()],
+		attempt: 1,
+		createdAt: NOW,
+		updatedAt: NOW,
+		...overrides,
+	};
+}
+
+function makePlan(overrides: Partial<UlwLoopPlan> = {}): UlwLoopPlan {
+	return {
+		version: 1,
+		createdAt: NOW,
+		updatedAt: NOW,
+		briefPath: ".omo/ulw-loop/brief.md",
+		goalsPath: ".omo/ulw-loop/goals.json",
+		ledgerPath: ".omo/ulw-loop/ledger.jsonl",
+		codexGoalMode: "aggregate",
+		codexObjective: ULW_LOOP_AGGREGATE_CODEX_OBJECTIVE,
+		goals: [makeGoal({ status: "in_progress" })],
+		...overrides,
+	};
+}
+
+async function bootstrapRepo(plan: UlwLoopPlan): Promise<string> {
+	const repo = await mkdtemp(join(tmpdir(), "ug-review-blockers-"));
+	await mkdir(ulwLoopDir(repo), { recursive: true });
+	await writePlan(repo, plan);
+	return repo;
+}
+
+async function ledgerKinds(repo: string): Promise<string[]> {
+	const raw = await readFile(ulwLoopLedgerPath(repo), "utf8");
+	return raw
+		.split(/\r?\n/)
+		.filter(Boolean)
+		.map((line) => JSON.parse(line).kind);
+}
+
+async function expectUlwLoopCode(action: () => Promise<unknown>, code: string): Promise<void> {
+	try {
+		await action();
+	} catch (error) {
+		expect(error).toBeInstanceOf(UlwLoopError);
+		if (!(error instanceof UlwLoopError)) throw error;
+		expect(error.code).toBe(code);
+		return;
+	}
+	throw new Error("Expected UlwLoopError");
+}
+
+function finalPlan(): UlwLoopPlan {
+	return makePlan({
+		activeGoalId: "G002",
+		goals: [
+			makeGoal({ id: "G001", status: "complete" }),
+			makeGoal({ id: "G002", status: "in_progress", title: "ship it", objective: "Finish final story" }),
+		],
+	});
+}
+
+describe("recordFinalReviewBlockers happy path", () => {
+	it("marks the final goal review_blocked + appends new pending goal", async () => {
+		const repo = await bootstrapRepo(finalPlan());
+
+		const result = await recordFinalReviewBlockers(repo, validArgs);
+
+		expect(result.blockedGoal.status).toBe("review_blocked");
+		expect(result.blockedGoal.evidence).toBe(validArgs.evidence);
+		expect(result.newGoal).toMatchObject({ id: "G003", status: "pending", title: validArgs.title });
+		expect(result.newGoal.successCriteria.length).toBeGreaterThanOrEqual(3);
+		expect(result.plan.activeGoalId).toBeUndefined();
+		expect(result.ledgerEntries.length).toBeGreaterThanOrEqual(3);
+	});
+
+	it("seeded successCriteria cover happy/edge/regression on the blocker-resolution goal", async () => {
+		const repo = await bootstrapRepo(finalPlan());
+
+		const result = await recordFinalReviewBlockers(repo, validArgs);
+
+		expect(result.newGoal.successCriteria.map((criterion) => criterion.userModel).sort()).toEqual([
+			"edge",
+			"happy",
+			"regression",
+		]);
+	});
+});
+
+describe("recordFinalReviewBlockers error cases", () => {
+	it("throws ulw_loop_goal_not_found for unknown goalId", async () => {
+		const repo = await bootstrapRepo(finalPlan());
+		await expectUlwLoopCode(
+			() => recordFinalReviewBlockers(repo, { ...validArgs, goalId: "G999" }),
+			"ulw_loop_goal_not_found",
+		);
+	});
+
+	it("throws ulw_loop_goal_not_in_progress when goal.status !== in_progress", async () => {
+		const repo = await bootstrapRepo(
+			makePlan({
+				goals: [makeGoal({ id: "G001", status: "in_progress" }), makeGoal({ id: "G002", status: "pending" })],
+			}),
+		);
+		await expectUlwLoopCode(() => recordFinalReviewBlockers(repo, validArgs), "ulw_loop_goal_not_in_progress");
+	});
+
+	it("throws ulw_loop_not_final_story when other unresolved goals remain", async () => {
+		const repo = await bootstrapRepo(
+			makePlan({
+				goals: [makeGoal({ id: "G001", status: "in_progress" }), makeGoal({ id: "G002", status: "pending" })],
+			}),
+		);
+		await expectUlwLoopCode(
+			() => recordFinalReviewBlockers(repo, { ...validArgs, goalId: "G001" }),
+			"ulw_loop_not_final_story",
+		);
+	});
+
+	it("throws ulw_loop_codex_snapshot_mismatch when objective mismatches", async () => {
+		const repo = await bootstrapRepo(finalPlan());
+		const codexGoalJson = JSON.stringify({ goal: { objective: "wrong", status: "active" } });
+
+		await expectUlwLoopCode(
+			() => recordFinalReviewBlockers(repo, { ...validArgs, codexGoalJson }),
+			"ulw_loop_codex_snapshot_mismatch",
+		);
+	});
+});
+
+describe("recordFinalReviewBlockers ledger entries", () => {
+	it("appends goal_review_blocked + goal_added + blocker_recorded events", async () => {
+		const repo = await bootstrapRepo(finalPlan());
+
+		await recordFinalReviewBlockers(repo, validArgs);
+
+		expect(await ledgerKinds(repo)).toEqual(["goal_review_blocked", "goal_added", "blocker_recorded"]);
+	});
+});

package/packages/omo-codex/plugin/components/ulw-loop/test/steering.test.ts

@@ -0,0 +1,353 @@
+import { mkdtemp, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { ulwLoopGoalsPath } from "../src/paths.js";
+import { readSteeringLedgerEntries, readUlwLoopPlan, writePlan } from "../src/plan-io.js";
+import {
+	applySteeringMutation,
+	parseUlwLoopSteeringDirective,
+	steerUlwLoop,
+	validateUlwLoopSteeringProposal,
+} from "../src/steering.js";
+import type {
+	UlwLoopItem,
+	UlwLoopPlan,
+	UlwLoopSteeringProposal,
+	UlwLoopSuccessCriterion,
+	UlwLoopSuccessCriterionUserModel,
+} from "../src/types.js";
+
+const NOW = "2026-05-23T00:00:00.000Z";
+
+type CriterionSteeringFields = {
+	readonly goalId?: string;
+	readonly scenario?: string;
+	readonly expectedEvidence?: string;
+	readonly userModel?: UlwLoopSuccessCriterionUserModel;
+};
+type SteeringInput = UlwLoopSteeringProposal & CriterionSteeringFields;
+
+function criterion(overrides: Partial<UlwLoopSuccessCriterion> = {}): UlwLoopSuccessCriterion {
+	return {
+		id: "C001",
+		scenario: "old scenario",
+		userModel: "happy",
+		expectedEvidence: "vague evidence",
+		capturedEvidence: null,
+		status: "pending",
+		...overrides,
+	};
+}
+
+function goal(overrides: Partial<UlwLoopItem> = {}): UlwLoopItem {
+	return {
+		id: "G001",
+		title: "Build auth service",
+		objective: "Implement JWT auth endpoint",
+		status: "pending",
+		successCriteria: [criterion(), criterion({ id: "C002", status: "pass" })],
+		attempt: 0,
+		createdAt: NOW,
+		updatedAt: NOW,
+		...overrides,
+	};
+}
+
+function plan(overrides: Partial<UlwLoopPlan> = {}): UlwLoopPlan {
+	return {
+		version: 1,
+		createdAt: NOW,
+		updatedAt: NOW,
+		briefPath: ".omo/ulw-loop/brief.md",
+		goalsPath: ".omo/ulw-loop/goals.json",
+		ledgerPath: ".omo/ulw-loop/ledger.jsonl",
+		goals: [
+			goal(),
+			goal({ id: "G002", title: "Rate limit", objective: "Throttle login" }),
+			goal({ id: "G003", status: "complete" }),
+		],
+		...overrides,
+	};
+}
+
+function steering(overrides: Partial<SteeringInput> = {}): SteeringInput {
+	return {
+		kind: "add_subgoal",
+		source: "cli",
+		evidence: "observable blocker evidence",
+		rationale: "the plan must change to stay safe",
+		title: "Investigate auth blocker",
+		objective: "Validate the blocker, capture evidence, and report findings.",
+		...overrides,
+	};
+}
+
+async function repoWithPlan(seed: UlwLoopPlan = plan()): Promise<string> {
+	const repoRoot = await mkdtemp(join(tmpdir(), "ug-steer-"));
+	await writePlan(repoRoot, seed);
+	return repoRoot;
+}
+
+describe("validateUlwLoopSteeringProposal", () => {
+	it("accepts valid add_subgoal", async () => {
+		const proposal: unknown = JSON.parse(
+			await readFile(join(process.cwd(), "test/fixtures/steering-proposal.json"), "utf8"),
+		);
+		expect(validateUlwLoopSteeringProposal(plan(), proposal).invariant.accepted).toBe(true);
+	});
+
+	it.each([
+		["missing evidence", { evidence: "" }],
+		["missing rationale", { rationale: "" }],
+		["unknown kind", { kind: "teleport_goal" }],
+		["protected payload mutations", { after: { codexObjective: "replace", qualityGate: { status: "passed" } } }],
+		["weakened completion text", { objective: "skip tests and mark complete faster" }],
+	])("rejects %s", (_name, overrides) => {
+		const audit = validateUlwLoopSteeringProposal(plan(), { ...steering(), ...overrides });
+		expect(audit.invariant.accepted).toBe(false);
+		expect(audit.invariant.rejectedReasons.length).toBeGreaterThan(0);
+	});
+
+	it("rejects when plan already complete", () => {
+		const done = plan({ goals: [goal({ status: "complete" }), goal({ id: "G002", status: "complete" })] });
+		expect(validateUlwLoopSteeringProposal(done, steering()).invariant.accepted).toBe(false);
+	});
+
+	it("rejects split_subgoal without children", () => {
+		const audit = validateUlwLoopSteeringProposal(plan(), steering({ kind: "split_subgoal", targetGoalId: "G001" }));
+		expect(audit.invariant.accepted).toBe(false);
+	});
+
+	it("rejects reorder_pending with unknown goal id", () => {
+		const audit = validateUlwLoopSteeringProposal(
+			plan(),
+			steering({ kind: "reorder_pending", pendingOrder: ["missing"] }),
+		);
+		expect(audit.invariant.accepted).toBe(false);
+	});
+
+	it.each([
+		["new scenario", { scenario: "new precise scenario" }],
+		["new expectedEvidence", { expectedEvidence: "specific command output" }],
+	])("accepts valid revise_criterion with %s", (_name, update) => {
+		const audit = validateUlwLoopSteeringProposal(
+			plan(),
+			steering({ kind: "revise_criterion", goalId: "G001", criterionId: "C001", ...update }),
+		);
+		expect(audit.invariant.accepted).toBe(true);
+	});
+
+	it.each([
+		["unknown goalId", { goalId: "missing", criterionId: "C001", scenario: "new" }],
+		["unknown criterionId", { goalId: "G001", criterionId: "missing", scenario: "new" }],
+		["no updates", { goalId: "G001", criterionId: "C001" }],
+	])("rejects revise_criterion with %s", (_name, overrides) => {
+		const audit = validateUlwLoopSteeringProposal(plan(), steering({ kind: "revise_criterion", ...overrides }));
+		expect(audit.invariant.accepted).toBe(false);
+	});
+});
+
+describe("steerUlwLoop", () => {
+	describe("steering-created goals", () => {
+		function sluggedPlan(): UlwLoopPlan {
+			return plan({
+				goals: [
+					goal({ id: "G001-goal-a", title: "Goal A", objective: "Do A" }),
+					goal({ id: "G002-goal-b", title: "Goal B", objective: "Do B" }),
+				],
+			});
+		}
+
+		it("add_subgoal: uses next numeric id + default success criteria", async () => {
+			const repoRoot = await repoWithPlan(sluggedPlan());
+			const result = await steerUlwLoop(repoRoot, steering({ idempotencyKey: "slug-add" }));
+			expect(result.plan.goals.at(-1)).toMatchObject({
+				id: "G003",
+				successCriteria: [{ id: "C001" }, { id: "C002" }, { id: "C003" }],
+			});
+		});
+
+		it("split_subgoal: replacement goals use default success criteria", async () => {
+			const repoRoot = await repoWithPlan(sluggedPlan());
+			const result = await steerUlwLoop(
+				repoRoot,
+				steering({
+					kind: "split_subgoal",
+					targetGoalId: "G001-goal-a",
+					childGoals: [{ title: "Child A", objective: "Do child A" }],
+				}),
+			);
+			expect(result.plan.goals[1]).toMatchObject({
+				id: "G003",
+				successCriteria: [{ id: "C001" }, { id: "C002" }, { id: "C003" }],
+			});
+		});
+
+		it("mark_blocked_superseded: replacement goals use default success criteria", async () => {
+			const repoRoot = await repoWithPlan(sluggedPlan());
+			const result = await steerUlwLoop(
+				repoRoot,
+				steering({
+					kind: "mark_blocked_superseded",
+					targetGoalId: "G001-goal-a",
+					childGoals: [{ title: "Replacement", objective: "Replace blocked path" }],
+				}),
+			);
+			expect(result.plan.goals[1]).toMatchObject({
+				id: "G003",
+				successCriteria: [{ id: "C001" }, { id: "C002" }, { id: "C003" }],
+			});
+		});
+	});
+
+	it("add_subgoal: appends goal + ledger entry", async () => {
+		const repoRoot = await repoWithPlan();
+		const result = await steerUlwLoop(repoRoot, steering({ idempotencyKey: "add" }));
+		const persisted = await readUlwLoopPlan(repoRoot);
+		expect(result.accepted).toBe(true);
+		expect(persisted.goals.at(-1)).toMatchObject({ id: "G004", title: "Investigate auth blocker" });
+		expect((await readSteeringLedgerEntries(repoRoot)).at(-1)).toMatchObject({
+			kind: "steering_accepted",
+			mutationKind: "add_subgoal",
+		});
+	});
+
+	it("split_subgoal: creates children + supersedes parent", async () => {
+		const repoRoot = await repoWithPlan();
+		const result = await steerUlwLoop(
+			repoRoot,
+			steering({
+				kind: "split_subgoal",
+				targetGoalId: "G001",
+				childGoals: [{ title: "Child", objective: "Do child" }],
+			}),
+		);
+		expect(result.plan.goals.map((item) => item.id).slice(0, 2)).toEqual(["G001", "G004"]);
+		expect(result.plan.goals[0]).toMatchObject({ steeringStatus: "superseded", supersededBy: ["G004"] });
+	});
+
+	it("reorder_pending: changes goal order", async () => {
+		const repoRoot = await repoWithPlan();
+		const result = await steerUlwLoop(
+			repoRoot,
+			steering({ kind: "reorder_pending", pendingOrder: ["G002", "G001"] }),
+		);
+		expect(result.plan.goals.map((item) => item.id).slice(0, 2)).toEqual(["G002", "G001"]);
+	});
+
+	it("revise_pending_wording: updates title/objective", async () => {
+		const repoRoot = await repoWithPlan();
+		const result = await steerUlwLoop(
+			repoRoot,
+			steering({
+				kind: "revise_pending_wording",
+				targetGoalId: "G001",
+				revisedTitle: "Build safer auth",
+				revisedObjective: "Implement guarded JWT auth",
+			}),
+		);
+		expect(result.plan.goals[0]).toMatchObject({
+			title: "Build safer auth",
+			objective: "Implement guarded JWT auth",
+		});
+	});
+
+	it("annotate_ledger: ledger-only, no plan mutation", async () => {
+		const seed = plan();
+		const repoRoot = await repoWithPlan(seed);
+		const result = await steerUlwLoop(repoRoot, steering({ kind: "annotate_ledger" }));
+		expect(result.plan.goals).toEqual(seed.goals);
+		expect(await readFile(ulwLoopGoalsPath(repoRoot), "utf8")).toBe(`${JSON.stringify(seed, null, 2)}\n`);
+	});
+
+	it("mark_blocked_superseded with children: supersede + replace", async () => {
+		const repoRoot = await repoWithPlan();
+		const result = await steerUlwLoop(
+			repoRoot,
+			steering({
+				kind: "mark_blocked_superseded",
+				targetGoalId: "G001",
+				childGoals: [{ title: "Replacement", objective: "Replace blocked path" }],
+			}),
+		);
+		expect(result.plan.goals[0]).toMatchObject({ steeringStatus: "superseded", supersededBy: ["G004"] });
+		expect(result.plan.goals[1]).toMatchObject({ id: "G004", supersedes: ["G001"] });
+	});
+
+	it("mark_blocked_superseded without children: blocks goal", async () => {
+		const repoRoot = await repoWithPlan();
+		const result = await steerUlwLoop(
+			repoRoot,
+			steering({ kind: "mark_blocked_superseded", targetGoalId: "G001", blockedReason: "external blocker" }),
+		);
+		expect(result.plan.goals[0]).toMatchObject({
+			status: "blocked",
+			steeringStatus: "blocked",
+			blockedReason: "external blocker",
+		});
+	});
+
+	it.each(["pending", "pass"] as const)("revise_criterion: works on a %s criterion", async (status) => {
+		const repoRoot = await repoWithPlan();
+		const criterionId = status === "pending" ? "C001" : "C002";
+		const result = await steerUlwLoop(
+			repoRoot,
+			steering({
+				kind: "revise_criterion",
+				goalId: "G001",
+				criterionId,
+				scenario: "new scenario",
+				expectedEvidence: "precise evidence",
+			}),
+		);
+		const updated = result.plan.goals[0]?.successCriteria.find((item) => item.id === criterionId);
+		expect(updated).toMatchObject({ scenario: "new scenario", expectedEvidence: "precise evidence", status });
+		expect((await readSteeringLedgerEntries(repoRoot)).at(-1)).toMatchObject({
+			kind: "criteria_revised",
+			criterionId,
+		});
+	});
+
+	it("revise_criterion: updates the targeted criterion in plan", () => {
+		const audit = validateUlwLoopSteeringProposal(
+			plan(),
+			steering({ kind: "revise_criterion", goalId: "G001", criterionId: "C001", scenario: "new value" }),
+		);
+		const next = applySteeringMutation(
+			plan(),
+			steering({ kind: "revise_criterion", goalId: "G001", criterionId: "C001", scenario: "new value" }),
+			audit,
+		);
+		expect(next.goals[0]?.successCriteria[0]?.scenario).toBe("new value");
+	});
+
+	it("idempotency: same idempotencyKey produces deduped true second time", async () => {
+		const repoRoot = await repoWithPlan();
+		await steerUlwLoop(repoRoot, steering({ idempotencyKey: "same-key" }));
+		const second = await steerUlwLoop(repoRoot, steering({ idempotencyKey: "same-key" }));
+		expect(second.deduped).toBe(true);
+		expect((await readUlwLoopPlan(repoRoot)).goals).toHaveLength(4);
+	});
+});
+
+describe("parseUlwLoopSteeringDirective", () => {
+	it.each(["OMO_ULW_LOOP_STEER", "omo.ulw-loop.steer", "omo ulw-loop steer"])("parses %s pattern", (marker) => {
+		expect(parseUlwLoopSteeringDirective(`${marker}: ${JSON.stringify(steering())}`)).toMatchObject({
+			kind: "add_subgoal",
+		});
+	});
+
+	it("returns null when no marker", () => {
+		expect(parseUlwLoopSteeringDirective(JSON.stringify(steering()))).toBeNull();
+	});
+
+	it("returns null when JSON malformed after marker", () => {
+		expect(parseUlwLoopSteeringDirective("OMO_ULW_LOOP_STEER: {bad json")).toBeNull();
+	});
+
+	it("returns null for deprecated markers", () => {
+		const marker = ["OM", "X_ULW_LOOP_STEER"].join("");
+		expect(parseUlwLoopSteeringDirective(`${marker}: ${JSON.stringify(steering())}`)).toBeNull();
+	});
+});

package/packages/omo-codex/plugin/components/ulw-loop/test/types.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it } from "vitest";
+
+import {
+	iso,
+	ULW_LOOP_BRIEF,
+	ULW_LOOP_CRITERION_STATUSES,
+	ULW_LOOP_DIR,
+	ULW_LOOP_GOALS,
+	ULW_LOOP_LEDGER,
+	ULW_LOOP_STEERING_MUTATION_KINDS,
+	ULW_LOOP_SUCCESS_CRITERION_USER_MODELS,
+	UlwLoopError,
+} from "../src/types.ts";
+
+describe("ulw-loop domain constants", () => {
+	describe("when checking workspace paths", () => {
+		it("then ULW_LOOP_DIR points to the omo workspace", () => {
+			expect(ULW_LOOP_DIR).toBe(".omo/ulw-loop");
+		});
+
+		it("then artifact filenames are stable", () => {
+			expect(ULW_LOOP_BRIEF).toBe("brief.md");
+			expect(ULW_LOOP_GOALS).toBe("goals.json");
+			expect(ULW_LOOP_LEDGER).toBe("ledger.jsonl");
+		});
+	});
+
+	describe("when checking steering mutation kinds", () => {
+		it("then includes the new revise_criterion kind", () => {
+			expect(ULW_LOOP_STEERING_MUTATION_KINDS).toContain("revise_criterion");
+		});
+
+		it("then totals 7 kinds", () => {
+			expect(ULW_LOOP_STEERING_MUTATION_KINDS).toHaveLength(7);
+		});
+	});
+
+	describe("when checking criterion user models", () => {
+		it("then exposes 4 user models including adversarial", () => {
+			expect(ULW_LOOP_SUCCESS_CRITERION_USER_MODELS).toEqual(["happy", "edge", "regression", "adversarial"]);
+		});
+	});
+
+	describe("when checking criterion statuses", () => {
+		it("then exposes pending/pass/fail/blocked", () => {
+			expect(ULW_LOOP_CRITERION_STATUSES).toEqual(["pending", "pass", "fail", "blocked"]);
+		});
+	});
+});
+
+describe("UlwLoopError", () => {
+	describe("when constructed with code", () => {
+		it("then is an Error instance carrying the code", () => {
+			const err = new UlwLoopError("bad", "TEST_CODE");
+
+			expect(err).toBeInstanceOf(Error);
+			expect(err.code).toBe("TEST_CODE");
+			expect(err.message).toBe("bad");
+		});
+
+		it("then accepts optional cause + details", () => {
+			const cause = new Error("upstream");
+			const err = new UlwLoopError("wrap", "WRAP", { cause, details: { goalId: "G001" } });
+
+			expect(err.cause).toBe(cause);
+			expect(err.details).toEqual({ goalId: "G001" });
+		});
+	});
+});
+
+describe("iso()", () => {
+	describe("when called", () => {
+		it("then returns an ISO 8601 string", () => {
+			const s = iso();
+
+			expect(s).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
+		});
+	});
+});

package/packages/omo-codex/plugin/components/ulw-loop/tsconfig.build.json

@@ -0,0 +1,12 @@
+{
+	"extends": "./tsconfig.json",
+	"compilerOptions": {
+		"allowImportingTsExtensions": false,
+		"declaration": true,
+		"outDir": "dist",
+		"rootDir": "src",
+		"noEmit": false
+	},
+	"include": ["src/**/*"],
+	"exclude": ["test/**/*"]
+}

package/packages/omo-codex/plugin/components/ulw-loop/tsconfig.json

@@ -0,0 +1,27 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "Node16",
+		"moduleResolution": "Node16",
+		"lib": ["ES2022"],
+		"strict": true,
+		"exactOptionalPropertyTypes": true,
+		"noUncheckedIndexedAccess": true,
+		"noPropertyAccessFromIndexSignature": true,
+		"verbatimModuleSyntax": true,
+		"noImplicitOverride": true,
+		"noImplicitReturns": true,
+		"noFallthroughCasesInSwitch": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"esModuleInterop": true,
+		"allowImportingTsExtensions": true,
+		"skipLibCheck": true,
+		"forceConsistentCasingInFileNames": true,
+		"resolveJsonModule": true,
+		"useDefineForClassFields": false,
+		"types": ["node"],
+		"noEmit": true
+	},
+	"include": ["src/**/*", "test/**/*", "vitest.config.ts"]
+}

package/packages/omo-codex/plugin/components/ulw-loop/vitest.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+	test: {
+		include: ["test/**/*.test.ts"],
+		environment: "node",
+		pool: "threads",
+		isolate: true,
+	},
+});