oh-my-opencode 4.7.4 → 4.8.0

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

@@ -15,6 +15,15 @@ import type { SteerUlwLoopResult, UlwLoopPlan } from "../src/types.js";
 import { UlwLoopError } from "../src/types.js";
 
 const NOW = "2026-05-23T00:00:00.000Z";
+const REVISE_CRITERION_BASE_ARGS = [
+	"--kind",
+	"revise_criterion",
+	"--goal-id",
+	"G001",
+	"--criterion-id",
+	"C002",
+] as const;
+const REQUIRED_AUDIT_ARGS = ["--evidence", "x", "--rationale", "y"] as const;
 
 function plan(): UlwLoopPlan {
 	return {
@@ -64,21 +73,23 @@ function captureStdout(action: () => void): string {
 }
 
 describe("parseSteeringKind", () => {
-	it("returns valid kind from --kind", () => {
-		expect(parseSteeringKind(["--kind", "add_subgoal"])).toBe("add_subgoal");
-	});
-
-	it("accepts revise_criterion", () => {
-		expect(parseSteeringKind(["--kind", "revise_criterion"])).toBe("revise_criterion");
-	});
-
-	it("throws when --kind missing", () => {
-		expect(() => parseSteeringKind([])).toThrow(UlwLoopError);
-	});
-
-	it("throws when kind unknown", () => {
-		expect(() => parseSteeringKind(["--kind", "bogus"])).toThrow(UlwLoopError);
-	});
+	for (const testCase of [
+		{ name: "returns valid kind from --kind", args: ["--kind", "add_subgoal"], expected: "add_subgoal" },
+		{ name: "accepts revise_criterion", args: ["--kind", "revise_criterion"], expected: "revise_criterion" },
+	] as const) {
+		it(testCase.name, () => {
+			expect(parseSteeringKind(testCase.args)).toBe(testCase.expected);
+		});
+	}
+
+	for (const testCase of [
+		{ name: "throws when --kind missing", args: [] },
+		{ name: "throws when kind unknown", args: ["--kind", "bogus"] },
+	] as const) {
+		it(testCase.name, () => {
+			expect(() => parseSteeringKind(testCase.args)).toThrow(UlwLoopError);
+		});
+	}
 });
 
 describe("parseSteeringSource", () => {
@@ -141,18 +152,10 @@ describe("parseSteeringProposal add_subgoal", () => {
 describe("parseSteeringProposal revise_criterion", () => {
 	it("builds proposal with goal, criterion, scenario, evidence, and rationale", async () => {
 		const p = await parseSteeringProposal([
-			"--kind",
-			"revise_criterion",
-			"--goal-id",
-			"G001",
-			"--criterion-id",
-			"C002",
+			...REVISE_CRITERION_BASE_ARGS,
 			"--scenario",
 			"new scenario",
-			"--evidence",
-			"x",
-			"--rationale",
-			"y",
+			...REQUIRED_AUDIT_ARGS,
 		]);
 
 		expect(p.kind).toBe("revise_criterion");
@@ -162,94 +165,47 @@ describe("parseSteeringProposal revise_criterion", () => {
 		expect(p.scenario).toBe("new scenario");
 	});
 
-	it("accepts --expected-evidence as an update field", async () => {
-		const p = await parseSteeringProposal([
-			"--kind",
-			"revise_criterion",
-			"--goal-id",
-			"G001",
-			"--criterion-id",
-			"C002",
-			"--expected-evidence",
-			"new evidence",
-			"--evidence",
-			"x",
-			"--rationale",
-			"y",
-		]);
-
-		expect(p.expectedEvidence).toBe("new evidence");
-	});
-
-	it("accepts --user-model as an update field", async () => {
-		const p = await parseSteeringProposal([
-			"--kind",
-			"revise_criterion",
-			"--goal-id",
-			"G001",
-			"--criterion-id",
-			"C002",
-			"--user-model",
-			"edge",
-			"--evidence",
-			"x",
-			"--rationale",
-			"y",
-		]);
-
-		expect(p.userModel).toBe("edge");
-	});
-
-	it("throws when none of scenario/expected-evidence/user-model provided", async () => {
-		await expect(
-			parseSteeringProposal([
-				"--kind",
-				"revise_criterion",
-				"--goal-id",
-				"G001",
-				"--criterion-id",
-				"C002",
-				"--evidence",
-				"x",
-				"--rationale",
-				"y",
-			]),
-		).rejects.toThrow(UlwLoopError);
-	});
+	for (const testCase of [
+		{
+			name: "accepts --expected-evidence as an update field",
+			updateArgs: ["--expected-evidence", "new evidence"],
+			expected: { expectedEvidence: "new evidence" },
+		},
+		{
+			name: "accepts --user-model as an update field",
+			updateArgs: ["--user-model", "edge"],
+			expected: { userModel: "edge" },
+		},
+	] as const) {
+		it(testCase.name, async () => {
+			const p = await parseSteeringProposal([
+				...REVISE_CRITERION_BASE_ARGS,
+				...testCase.updateArgs,
+				...REQUIRED_AUDIT_ARGS,
+			]);
 
-	it("throws when goal-id missing", async () => {
-		await expect(
-			parseSteeringProposal([
-				"--kind",
-				"revise_criterion",
-				"--criterion-id",
-				"C002",
-				"--scenario",
-				"s",
-				"--evidence",
-				"x",
-				"--rationale",
-				"y",
-			]),
-		).rejects.toThrow(UlwLoopError);
-	});
+			expect(p).toMatchObject(testCase.expected);
+		});
+	}
 
-	it("throws when criterion-id missing", async () => {
-		await expect(
-			parseSteeringProposal([
-				"--kind",
-				"revise_criterion",
-				"--goal-id",
-				"G001",
-				"--scenario",
-				"s",
-				"--evidence",
-				"x",
-				"--rationale",
-				"y",
-			]),
-		).rejects.toThrow(UlwLoopError);
-	});
+	for (const testCase of [
+		{
+			name: "throws when none of scenario/expected-evidence/user-model provided",
+			args: [...REVISE_CRITERION_BASE_ARGS, ...REQUIRED_AUDIT_ARGS],
+		},
+		{
+			name: "throws when goal-id missing",
+			args: ["--kind", "revise_criterion", "--criterion-id", "C002", "--scenario", "s", ...REQUIRED_AUDIT_ARGS],
+		},
+		{
+			name: "throws when criterion-id missing",
+			args: ["--kind", "revise_criterion", "--goal-id", "G001", "--scenario", "s", ...REQUIRED_AUDIT_ARGS],
+		},
+	] as const) {
+		it(testCase.name, async () => {
+			await expect(parseSteeringProposal(testCase.args)).rejects.toThrow(UlwLoopError);
+		});
+	}
 });
 
 describe("parseSteeringProposal split_subgoal", () => {

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

@@ -59,9 +59,9 @@ describe("buildCodexGoalInstruction aggregate mode", () => {
 		});
 		expect(json).toEqual({
 			objective: ULW_LOOP_AGGREGATE_CODEX_OBJECTIVE,
-			status: "active",
 		});
-		expect(text).toContain("objective and status only");
+		expect(text).toContain("objective only");
+		expect(text).not.toContain('"status"');
 		expect(text).toContain("Goals are unlimited");
 		expect(text).not.toMatch(/token[_-]?budget/i);
 	});

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

@@ -229,8 +229,37 @@ describe("applyPreToolUseGoalBudgetGuard", () => {
 				permissionDecision: "deny",
 			},
 		});
-		expect(parsed.hookSpecificOutput.permissionDecisionReason).toContain("Do not set token_budget on create_goal");
+		expect(parsed.hookSpecificOutput.permissionDecisionReason).toContain("objective only");
+		expect(parsed.hookSpecificOutput.permissionDecisionReason).toContain("token_budget");
 		expect(parsed.hookSpecificOutput.permissionDecisionReason).toContain("unlimited");
+		expect(parsed.hookSpecificOutput.permissionDecisionReason).toContain("update_goal");
+	});
+
+	it("#given create_goal sets status #when PreToolUse runs #then it blocks with objective-only warning", () => {
+		// given
+		const input = preToolPayload("create_goal", { objective: "Ship the feature", status: "active" });
+
+		// when
+		const output = applyPreToolUseGoalBudgetGuard(input);
+
+		// then
+		const parsed = JSON.parse(output);
+		expect(parsed.hookSpecificOutput.permissionDecision).toBe("deny");
+		expect(parsed.hookSpecificOutput.permissionDecisionReason).toContain("objective only");
+		expect(parsed.hookSpecificOutput.permissionDecisionReason).toContain("update_goal");
+	});
+
+	it("#given create_goal sets an unknown field #when PreToolUse runs #then it blocks with objective-only warning", () => {
+		// given
+		const input = preToolPayload("create_goal", { objective: "Ship the feature", statusText: "active" });
+
+		// when
+		const output = applyPreToolUseGoalBudgetGuard(input);
+
+		// then
+		const parsed = JSON.parse(output);
+		expect(parsed.hookSpecificOutput.permissionDecision).toBe("deny");
+		expect(parsed.hookSpecificOutput.permissionDecisionReason).toContain("objective only");
 	});
 
 	it("#given create_goal omits token_budget #when PreToolUse runs #then it stays silent", () => {
@@ -246,7 +275,7 @@ describe("applyPreToolUseGoalBudgetGuard", () => {
 
 	it("#given a neighboring tool includes token_budget text #when PreToolUse runs #then it stays silent", () => {
 		// given
-		const input = preToolPayload("update_goal", { status: "complete", token_budget: 5000 });
+		const input = preToolPayload("update_goal", { status: "complete", token_budget: 5000, statusText: "done" });
 
 		// when
 		const output = applyPreToolUseGoalBudgetGuard(input);

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

@@ -59,10 +59,10 @@ describe("package.json", () => {
 		expect((pkg["engines"] as Record<string, unknown>)["node"]).toBe(">=20.0.0");
 	});
 
-	it("exposes the omo binary pointing at dist/cli.js", async () => {
+	it("#given package metadata #when bin is inspected #then exposes the omo-ulw-loop binary pointing at dist/cli.js", async () => {
 		const pkg = await readJson("package.json") as Record<string, unknown>;
 		const bin = pkg["bin"] as Record<string, string>;
-		expect(bin["omo"]).toBe("./dist/cli.js");
+		expect(bin["omo-ulw-loop"]).toBe("./dist/cli.js");
 	});
 
 	it("ships the expected files for npm publish", async () => {
@@ -144,6 +144,14 @@ describe("skills/ulw-loop/SKILL.md", () => {
 		expect(text.toLowerCase()).toContain("record-evidence");
 	});
 
+	it("#given workflow Acquire Next Goal text #when inspected #then create_goal uses objective-only payload wording", async () => {
+		const text = await readText("skills/ulw-loop/references/full-workflow.md");
+
+		expect(text).toContain("instruction.json.objective");
+		expect(text).toContain("objective only");
+		expect(text).not.toContain("Call `create_goal` with the handoff payload.");
+	});
+
 	it("#given omo is absent from PATH #when bootstrap instructions are read #then local cached CLI fallback is documented", async () => {
 		const text = await readText("skills/ulw-loop/references/full-workflow.md");
 
@@ -210,19 +218,33 @@ describe("skills/ulw-loop/SKILL.md", () => {
 		expect(text).toContain(".omo/ulw-loop");
 	});
 
+	it("#given completed default state #when skill guidance is inspected #then it prefers a fresh session", async () => {
+		const skill = await readText("skills/ulw-loop/SKILL.md");
+		const workflow = await readText("skills/ulw-loop/references/full-workflow.md");
+
+		expect(skill).toContain("fresh `--session-id <new-id>`");
+		expect(skill).toContain("Use `--force` only");
+		expect(workflow).toContain("create-goals --session-id <new-id>");
+		expect(workflow).toContain("overwriting completed evidence");
+	});
+
 	it("#given long Codex runs #when worker guidance is inspected #then avoids context-expensive agent polling", async () => {
 		const text = await readText("skills/ulw-loop/references/full-workflow.md");
 
 		expect(text).toMatch(/list_agents/);
-		expect(text).toMatch(/polling or status tool/);
-		expect(text).toMatch(/replay large agent status and latest-message payloads/);
+		expect(text).toMatch(/polling loop/);
+		expect(text).toMatch(/replay large payloads/);
 		expect(text).toMatch(/Track spawned agent names locally/);
-		expect(text).toMatch(/wait_agent.*completion/);
-		expect(text).toMatch(/targeted followups only when needed/);
-		expect(text).toMatch(/close_agent.*after integrating each result/);
+		expect(text).toMatch(/wait_agent.*mailbox signals/);
+		expect(text).toMatch(/WORKING:/);
+		expect(text).toMatch(/single `list_agents`/);
 		expect(text).toMatch(/Plan and reviewer agents may run for a long time/);
 		expect(text).toMatch(/short wait_agent cycles/);
 		expect(text).toMatch(/single long blocking wait/);
+		expect(text).toMatch(/git-master/);
+		expect(text).toMatch(/touched-path commit history/);
+		expect(text).toMatch(/commit in the observed style/);
+		expect(text).toMatch(/omnibus commit/);
 		expect(text).toContain("Every worker message MUST carry");
 		expect(text).toContain("Each worker does strict TDD");
 	});
@@ -232,12 +254,27 @@ describe("skills/ulw-loop/SKILL.md", () => {
 
 		expect(text).toMatch(/TASK:/);
 		expect(text).toMatch(/fork_turns:\s*"none"/);
-		expect(text).toMatch(/wait_agent.*signal, not proof/);
-		expect(text).toMatch(/one targeted followup/);
+		expect(text).toMatch(/wait_agent.*mailbox signals/);
+		expect(text).toMatch(/WORKING:/);
+		expect(text).toMatch(/single `list_agents`/);
+		expect(text).toMatch(/Fallback only when/);
+		expect(text).toMatch(/BLOCKED:/);
 		expect(text).toMatch(/respawn.*smaller/);
 		expect(text).toMatch(/Plan and reviewer agents may run for a long time/);
 		expect(text).toMatch(/short wait_agent cycles/);
 		expect(text).toMatch(/single long blocking wait/);
+		expect(text).toMatch(/git-master/);
+		expect(text).toMatch(/commit each verified work unit atomically/);
+	});
+
+	it("#given quiet Codex reviewers #when full workflow guidance is inspected #then timeout is not treated as death", async () => {
+		const text = await readText("skills/ulw-loop/references/full-workflow.md");
+
+		expect(text).toMatch(/A timeout only means no new mailbox update arrived/i);
+		expect(text).toMatch(/WORKING:/);
+		expect(text).toMatch(/single `list_agents`/);
+		expect(text).toMatch(/do not count it as pass\/review approval/i);
+		expect(text).toMatch(/record inconclusive/i);
 	});
 });
 

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

@@ -159,46 +159,37 @@ describe("steerUlwLoop", () => {
 			});
 		}
 
-		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,
+		for (const [name, proposal, goalIndex] of [
+			["add_subgoal: uses next numeric id + default success criteria", steering({ idempotencyKey: "slug-add" }), -1],
+			[
+				"split_subgoal: replacement goals use default success criteria",
 				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,
+				1,
+			],
+			[
+				"mark_blocked_superseded: replacement goals use default success criteria",
 				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" }],
+				1,
+			],
+		] as const) {
+			it(name, async () => {
+				const repoRoot = await repoWithPlan(sluggedPlan());
+				const result = await steerUlwLoop(repoRoot, proposal);
+				const createdGoal = goalIndex === -1 ? result.plan.goals.at(-1) : result.plan.goals[goalIndex];
+				expect(createdGoal).toMatchObject({
+					id: "G003",
+					successCriteria: [{ id: "C001" }, { id: "C002" }, { id: "C003" }],
+				});
 			});
-		});
+		}
 	});
 
 	it("add_subgoal: appends goal + ledger entry", async () => {

package/packages/omo-codex/plugin/model-catalog.json

@@ -1,5 +1,5 @@
 {
-	"version": "2026-06-03.gpt-5.5-400k",
+	"version": "2026-06-04.gpt-5.5-400k-reviewer-high",
 	"current": {
 		"model": "gpt-5.5",
 		"model_context_window": 400000,
@@ -15,24 +15,18 @@
 		},
 		"verifier": {
 			"model": "gpt-5.5",
-			"model_reasoning_effort": "xhigh"
+			"model_reasoning_effort": "high"
 		},
 		"worker": {
-			"model": "gpt-5.4",
+			"model": "gpt-5.5",
 			"model_reasoning_effort": "high"
 		}
 	},
 	"managedProfiles": [
 		{
-			"version": "legacy.gpt-5.2",
+			"version": "legacy.gpt-5.5-1m",
 			"match": {
-				"model": "gpt-5.2"
-			}
-		},
-		{
-			"version": "legacy.gpt-5.4-1m",
-			"match": {
-				"model": "gpt-5.4",
+				"model": "gpt-5.5",
 				"model_context_window": 1000000,
 				"model_reasoning_effort": "high",
 				"plan_mode_reasoning_effort": "xhigh"

package/packages/omo-codex/plugin/package-lock.json

@@ -176,7 +176,7 @@
 			"version": "0.1.0",
 			"license": "MIT",
 			"bin": {
-				"omo": "dist/cli.js"
+				"omo-ulw-loop": "dist/cli.js"
 			},
 			"devDependencies": {
 				"@biomejs/biome": "2.4.15",

package/packages/omo-codex/plugin/scripts/auto-update-state.mjs

@@ -0,0 +1,78 @@
+import { appendFile, mkdir, open, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+export const DEFAULT_LOCK_STALE_MS = 10 * 60 * 1_000;
+
+export function resolveStatePath(env) {
+	if (env.LAZYCODEX_AUTO_UPDATE_STATE_PATH?.trim()) return env.LAZYCODEX_AUTO_UPDATE_STATE_PATH;
+	const dataRoot = env.PLUGIN_DATA?.trim() || join(homedir(), ".local", "share", "lazycodex");
+	return join(dataRoot, "auto-update.json");
+}
+
+export function resolveLogPath(env) {
+	if (env.LAZYCODEX_AUTO_UPDATE_LOG_PATH?.trim()) return env.LAZYCODEX_AUTO_UPDATE_LOG_PATH;
+	const dataRoot = env.PLUGIN_DATA?.trim() || join(homedir(), ".local", "share", "lazycodex");
+	return join(dataRoot, "auto-update.log");
+}
+
+export function resolveLockPath(env, statePath) {
+	if (env.LAZYCODEX_AUTO_UPDATE_LOCK_PATH?.trim()) return env.LAZYCODEX_AUTO_UPDATE_LOCK_PATH;
+	return `${statePath}.lock`;
+}
+
+export async function acquireLock(lockPath, now, staleMs = DEFAULT_LOCK_STALE_MS) {
+	await mkdir(dirname(lockPath), { recursive: true });
+	try {
+		const handle = await open(lockPath, "wx");
+		await handle.writeFile(`${now}\n`);
+		await handle.close();
+		return {
+			release: () => rm(lockPath, { force: true }),
+		};
+	} catch (error) {
+		if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) throw error;
+		if (!(await removeStaleLock(lockPath, now, staleMs))) return null;
+		return acquireLock(lockPath, now, 0);
+	}
+}
+
+export async function readState(statePath) {
+	try {
+		const raw = await readFile(statePath, "utf8");
+		const parsed = JSON.parse(raw);
+		return typeof parsed === "object" && parsed !== null ? parsed : {};
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return {};
+		return {};
+	}
+}
+
+export async function writeState(statePath, state) {
+	await mkdir(dirname(statePath), { recursive: true });
+	await writeFile(statePath, `${JSON.stringify(state, null, 2)}\n`);
+}
+
+export async function appendUpdateLog(env, now, event, details = {}) {
+	const logPath = resolveLogPath(env);
+	await mkdir(dirname(logPath), { recursive: true });
+	const entry = {
+		timestamp: new Date(now).toISOString(),
+		event,
+		...details,
+	};
+	await appendFile(logPath, `${JSON.stringify(entry)}\n`);
+}
+
+async function removeStaleLock(lockPath, now, staleMs) {
+	if (staleMs <= 0) return false;
+	try {
+		const lockStat = await stat(lockPath);
+		if (now - lockStat.mtimeMs < staleMs) return false;
+		await rm(lockPath, { force: true });
+		return true;
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return true;
+		throw error;
+	}
+}