oh-my-opencode 4.7.3 → 4.7.5

package/packages/omo-codex/plugin/components/rules/test/sources.test.ts

@@ -24,7 +24,7 @@ describe("rules source selection", () => {
 		// given
 		const config: PiRulesConfig = {
 			...defaultConfig(),
-			enabledSources: [".omo/rules", "AGENTS.md"],
+			enabledSources: [".omo/rules", "plugin-bundled"],
 		};
 
 		// when
@@ -33,13 +33,14 @@ describe("rules source selection", () => {
 		if (disabledSources === undefined) return;
 
 		// then
-		for (const source of [".omo/rules", "AGENTS.md"]) {
+		for (const source of [".omo/rules", "plugin-bundled"]) {
 			expect(disabledSources.has(source)).toBe(false);
 		}
-		expect(disabledSources.has("plugin-bundled")).toBe(true);
 		expect(disabledSources.has("~/.claude/rules")).toBe(true);
 		expect(disabledSources).toEqual(
-			new Set([...SOURCE_PRIORITY.keys()].filter((source) => source !== ".omo/rules" && source !== "AGENTS.md")),
+			new Set(
+				[...SOURCE_PRIORITY.keys()].filter((source) => source !== ".omo/rules" && source !== "plugin-bundled"),
+			),
 		);
 	});
 });

package/packages/omo-codex/plugin/components/ulw-loop/skills/ulw-loop/references/full-workflow.md

@@ -172,7 +172,7 @@ Trigger only when one goal remains and all its criteria are passing.
 1. Run targeted verification for changed behavior.
 2. Run `ai-slop-cleaner` on changed files. If no relevant edits exist, record a passed no-op cleaner report.
 3. Rerun verification after cleanup.
-4. Run `$code-review`.
+4. Judge the change size. Spawn the `codex-ultrawork-reviewer` agent (`spawn_agent(agent_type="codex-ultrawork-reviewer", fork_turns="none", ...)`; fall back to `agent_type="worker"` with a scoped reviewer assignment if unavailable) only when the work is large or risky (multi-file, cross-cutting, new architecture, security/data surfaces, or you are unsure it is sound); for a small, local, low-risk change, do the review yourself and record `codeReview` with `evidence` starting `UNCONDITIONAL APPROVAL` plus a one-line justification of why the change was small enough to self-review.
 5. Clean review means `codeReview.recommendation == "APPROVE"` and `codeReview.architectStatus == "CLEAR"`.
 6. If review is non-clean, run `omo ulw-loop record-review-blockers --goal-id <id> --title "<...>" --objective "<...>" --evidence "<review findings>" --codex-goal-json <snapshot> --json`.
 7. If clean, checkpoint final completion:

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

@@ -100,18 +100,18 @@ function formatCriterionLine(criterion: UlwLoopSuccessCriterion): string {
 
 function finalSection(plan: UlwLoopPlan, goal: UlwLoopItem, isFinal: boolean, aggregate: boolean): string {
 	if (!isFinal)
-		return "- This is not the final ulw-loop story; do not run the final ai-slop-cleaner/$code-review gate yet.";
+		return "- This is not the final ulw-loop story; do not run the final ai-slop-cleaner/code-review gate yet.";
 	const option = sessionOption(plan);
 	const blockerCommand = `omo ulw-loop record-review-blockers${option} --goal-id ${goal.id} --title "Resolve final code-review blockers" --objective "<blocker-resolution objective>" --evidence "<review findings>" --codex-goal-json "<active get_goal JSON or path>"`;
 	const checkpointCommand = `omo ulw-loop checkpoint${option} --goal-id ${goal.id} --status complete --evidence "<tests/files/PR evidence>" --codex-goal-json "<fresh complete get_goal JSON or path>" --quality-gate-json "<quality gate JSON or path>"`;
 	return joinLines([
 		"Final story — run mandatory quality gate before update_goal:",
-		"- Run ai-slop-cleaner on changed files even when it is a no-op, rerun verification, then run $code-review.",
-		"- If final $code-review is not APPROVE with architect status CLEAR, do not call update_goal. Record blocker work first:",
+		"- Run ai-slop-cleaner on changed files even when it is a no-op, rerun verification, then run the code review (spawn_agent(agent_type=\"codex-ultrawork-reviewer\", fork_turns=\"none\", ...); fall back to agent_type=\"worker\" with a scoped reviewer assignment if unavailable).",
+		"- If the final review is not APPROVE with architect status CLEAR, do not call update_goal. Record blocker work first:",
 		`  ${blockerCommand}`,
 		aggregate
-			? '- If final $code-review is clean, call update_goal({status: "complete"}), call get_goal again, then checkpoint the aggregate story:'
-			: '- If final $code-review is clean, call update_goal({status: "complete"}), call get_goal again, then checkpoint:',
+			? '- If the final review is clean, call update_goal({status: "complete"}), call get_goal again, then checkpoint the aggregate story:'
+			: '- If the final review is clean, call update_goal({status: "complete"}), call get_goal again, then checkpoint:',
 		`  ${checkpointCommand}`,
 	]);
 }

package/packages/omo-codex/plugin/components/ulw-loop/src/quality-gate.ts

@@ -12,6 +12,7 @@ const GHCR_PATTERN =
 	/\b(ghcr|github container registry|read packages|imagepullsecret|package api|anonymous|container image)\b/;
 const GHCR_401_PATTERN = /\b(401|unauthorized|anonymous pull|authentication required)\b/;
 const GHCR_403_PATTERN = /\b(403|forbidden|read packages|package api)\b/;
+const UNCONDITIONAL_APPROVAL_PATTERN = /\bUNCONDITIONAL\s+APPROVAL\b/i;
 
 function invalid(message: string, field: string): never {
 	throw new UlwLoopError(message, "ULW_LOOP_QUALITY_GATE_INVALID", { details: { field } });
@@ -42,6 +43,58 @@ function stringArray(value: unknown, field: string): string[] {
 	return value.map((item) => nonEmptyString(item, field));
 }
 
+function normalizeReviewerField({
+	value,
+	field,
+	expectedValue,
+	evidenceApproved,
+}: {
+	value: unknown;
+	field: string;
+	expectedValue: "APPROVE";
+	evidenceApproved: boolean;
+}): "APPROVE";
+function normalizeReviewerField({
+	value,
+	field,
+	expectedValue,
+	evidenceApproved,
+}: {
+	value: unknown;
+	field: string;
+	expectedValue: "CLEAR";
+	evidenceApproved: boolean;
+}): "CLEAR";
+function normalizeReviewerField({
+	value,
+	field,
+	expectedValue,
+	evidenceApproved,
+}: {
+	value: unknown;
+	field: string;
+	expectedValue: "APPROVE" | "CLEAR";
+	evidenceApproved: boolean;
+}): "APPROVE" | "CLEAR" {
+	if (typeof value === "string") {
+		const trimmed = value.trim();
+		if (trimmed === "") {
+			if (evidenceApproved) return expectedValue;
+			invalid(
+				`${field} must be ${expectedValue} or codeReview.evidence should include UNCONDITIONAL APPROVAL.`,
+				field,
+			);
+		}
+		if (trimmed === expectedValue) return expectedValue;
+		invalid(`${field} must be ${expectedValue}.`, field);
+	}
+	if (value === undefined) {
+		if (evidenceApproved) return expectedValue;
+		invalid(`${field} must be ${expectedValue} or codeReview.evidence should include UNCONDITIONAL APPROVAL.`, field);
+	}
+	invalid(`${field} must be ${expectedValue}.`, field);
+}
+
 export function validateQualityGate(input: unknown): UlwLoopQualityGate {
 	const gate = section(input, "qualityGate");
 	const cleaner = section(gate["aiSlopCleaner"], "aiSlopCleaner");
@@ -50,8 +103,6 @@ export function validateQualityGate(input: unknown): UlwLoopQualityGate {
 	const coverage = section(gate["criteriaCoverage"], "criteriaCoverage");
 	if (cleaner["status"] !== "passed") invalid("aiSlopCleaner.status must be passed.", "aiSlopCleaner.status");
 	if (verification["status"] !== "passed") invalid("verification.status must be passed.", "verification.status");
-	if (review["recommendation"] !== "APPROVE") invalid("recommendation must be APPROVE.", "codeReview.recommendation");
-	if (review["architectStatus"] !== "CLEAR") invalid("architectStatus must be CLEAR.", "codeReview.architectStatus");
 	const totalCriteria = numberField(coverage["totalCriteria"], "criteriaCoverage.totalCriteria");
 	const passCount = numberField(coverage["passCount"], "criteriaCoverage.passCount");
 	if (passCount < totalCriteria)
@@ -61,10 +112,23 @@ export function validateQualityGate(input: unknown): UlwLoopQualityGate {
 	const cleanerEvidence = nonEmptyString(cleaner["evidence"], "aiSlopCleaner.evidence");
 	const verificationEvidence = nonEmptyString(verification["evidence"], "verification.evidence");
 	const reviewEvidence = nonEmptyString(review["evidence"], "codeReview.evidence");
+	const approvalEvidence = UNCONDITIONAL_APPROVAL_PATTERN.test(reviewEvidence);
+	const recommendation = normalizeReviewerField({
+		value: review["recommendation"],
+		field: "codeReview.recommendation",
+		expectedValue: "APPROVE",
+		evidenceApproved: approvalEvidence,
+	});
+	const architectStatus = normalizeReviewerField({
+		value: review["architectStatus"],
+		field: "codeReview.architectStatus",
+		expectedValue: "CLEAR",
+		evidenceApproved: approvalEvidence,
+	});
 	const result: UlwLoopQualityGate = {
 		aiSlopCleaner: { status: "passed", evidence: cleanerEvidence },
 		verification: { status: "passed", commands, evidence: verificationEvidence },
-		codeReview: { recommendation: "APPROVE", architectStatus: "CLEAR", evidence: reviewEvidence },
+		codeReview: { recommendation, architectStatus, evidence: reviewEvidence },
 	};
 	Object.assign(result, { criteriaCoverage: { totalCriteria, passCount, adversarialClassesCovered: covered } });
 	return result;

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

@@ -81,6 +81,57 @@ describe("validateQualityGate", () => {
 		expect(gate).toMatchObject({ criteriaCoverage: { totalCriteria: 9, passCount: 9 } });
 	});
 
+	it("infers APPROVE/CLEAR when clean reviewer evidence omits structured fields", () => {
+		// given
+		const input = makeGate({
+			codeReview: {
+				evidence: "UNCONDITIONAL APPROVAL\nAll criteria and QA evidence are complete.",
+			},
+		});
+
+		// when
+		const gate = validateQualityGate(input);
+
+		// then
+		expect(gate.codeReview.recommendation).toBe("APPROVE");
+		expect(gate.codeReview.architectStatus).toBe("CLEAR");
+		expect(gate.codeReview.evidence).toBe("UNCONDITIONAL APPROVAL\nAll criteria and QA evidence are complete.");
+	});
+
+	it("infers APPROVE/CLEAR when clean reviewer evidence has blank structured fields", () => {
+		// given
+		const input = makeGate({
+			codeReview: {
+				recommendation: "",
+				architectStatus: "   ",
+				evidence: "UNCONDITIONAL APPROVAL\nAll criteria and QA evidence are complete.",
+			},
+		});
+
+		// when
+		const gate = validateQualityGate(input);
+
+		// then
+		expect(gate.codeReview.recommendation).toBe("APPROVE");
+		expect(gate.codeReview.architectStatus).toBe("CLEAR");
+	});
+
+	it("throws when reviewer fields are omitted and evidence has no approval verdict", () => {
+		// given
+		const input = makeGate({
+			codeReview: {
+				evidence: "review completed without an explicit verdict",
+			},
+		});
+
+		// when
+		const error = getQualityGateError(input);
+
+		// then
+		expect(error.code).toBe("ULW_LOOP_QUALITY_GATE_INVALID");
+		expect(error.message).toContain("UNCONDITIONAL APPROVAL");
+	});
+
 	it("throws UlwLoopError when aiSlopCleaner missing", () => {
 		// when
 		const error = getQualityGateError(makeGate({ aiSlopCleaner: undefined }));

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

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import { spawn, spawnSync } from "node:child_process";
-import { mkdir, open, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { appendFile, mkdir, open, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { pathToFileURL } from "node:url";
@@ -40,14 +40,19 @@ export async function runAutoUpdateCheck({ env = process.env, now = Date.now() }
 	if (!plan.shouldRun) return { started: false, reason: plan.reason };
 
 	const lock = await acquireLock(resolveLockPath(env, statePath), now, env);
-	if (lock === null) return { started: false, reason: "locked" };
+	if (lock === null) {
+		await appendUpdateLog(env, now, "locked");
+		return { started: false, reason: "locked" };
+	}
 	try {
 		await writeState(statePath, { lastCheckedAt: now });
+		await appendUpdateLog(env, now, "started", { command: plan.command, args: plan.args });
 		if (env.LAZYCODEX_AUTO_UPDATE_WAIT === "1") {
 			const result = spawnSync(plan.command, plan.args, {
 				env: plan.env,
 				stdio: "ignore",
 			});
+			await appendUpdateLog(env, now, "finished", { status: result.status ?? 0 });
 			return { started: true, status: result.status ?? 0 };
 		}
 
@@ -94,6 +99,12 @@ function resolveStatePath(env) {
 	return join(dataRoot, "auto-update.json");
 }
 
+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");
+}
+
 function resolveLockPath(env, statePath) {
 	if (env.LAZYCODEX_AUTO_UPDATE_LOCK_PATH?.trim()) return env.LAZYCODEX_AUTO_UPDATE_LOCK_PATH;
 	return `${statePath}.lock`;
@@ -145,6 +156,17 @@ async function writeState(statePath, state) {
 	await writeFile(statePath, `${JSON.stringify(state, null, 2)}\n`);
 }
 
+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`);
+}
+
 function parsePositiveInteger(value, fallback) {
 	if (value === undefined || value === "") return fallback;
 	const parsed = Number.parseInt(value, 10);

package/packages/omo-codex/plugin/skills/rules/SKILL.md

@@ -14,10 +14,8 @@ Dynamic `PostToolUse` output is injected as additional context and is deduplicat
 
 Supported project sources:
 
-- `AGENTS.md`
-- `CLAUDE.md`
 - `CONTEXT.md`
-- `.sisyphus/rules/**/*.md`
+- `.omo/rules/**/*.md`
 - `.claude/rules/**/*.md`
 - `.cursor/rules/**/*.md`
 - `.github/instructions/**/*.md`
@@ -29,6 +27,6 @@ Supported environment knobs:
 - `CODEX_RULES_MODE=both|static|dynamic|off`
 - `CODEX_RULES_MAX_RULE_CHARS=<number>`
 - `CODEX_RULES_MAX_RESULT_CHARS=<number>`
-- `CODEX_RULES_ENABLED_SOURCES=AGENTS.md,.sisyphus/rules`
+- `CODEX_RULES_ENABLED_SOURCES=CONTEXT.md,.omo/rules`
 
 The legacy `PI_RULES_*` variables are accepted as fallbacks for users migrating from `pi-rules`.

package/packages/omo-codex/plugin/skills/ulw-loop/references/full-workflow.md

@@ -172,7 +172,7 @@ Trigger only when one goal remains and all its criteria are passing.
 1. Run targeted verification for changed behavior.
 2. Run `ai-slop-cleaner` on changed files. If no relevant edits exist, record a passed no-op cleaner report.
 3. Rerun verification after cleanup.
-4. Run `$code-review`.
+4. Judge the change size. Spawn the `codex-ultrawork-reviewer` agent (`spawn_agent(agent_type="codex-ultrawork-reviewer", fork_turns="none", ...)`; fall back to `agent_type="worker"` with a scoped reviewer assignment if unavailable) only when the work is large or risky (multi-file, cross-cutting, new architecture, security/data surfaces, or you are unsure it is sound); for a small, local, low-risk change, do the review yourself and record `codeReview` with `evidence` starting `UNCONDITIONAL APPROVAL` plus a one-line justification of why the change was small enough to self-review.
 5. Clean review means `codeReview.recommendation == "APPROVE"` and `codeReview.architectStatus == "CLEAR"`.
 6. If review is non-clean, run `omo ulw-loop record-review-blockers --goal-id <id> --title "<...>" --objective "<...>" --evidence "<review findings>" --codex-goal-json <snapshot> --json`.
 7. If clean, checkpoint final completion:

package/packages/omo-codex/plugin/test/auto-update.test.mjs

@@ -43,6 +43,7 @@ test("#given recent state #when resolving plan #then update is throttled", () =>
 test("#given test command override #when running check #then records state and launches command", async () => {
 	const root = await mkdtemp(join(tmpdir(), "lazycodex-auto-update-"));
 	const logPath = join(root, "spawn.log");
+	const updateLogPath = join(root, "auto-update.log");
 	const statePath = join(root, "state.json");
 	const codexHome = join(root, "codex-home");
 
@@ -51,6 +52,7 @@ test("#given test command override #when running check #then records state and l
 			CODEX_HOME: codexHome,
 			LAZYCODEX_MODEL_CATALOG_STATE_PATH: join(root, "model-state.json"),
 			LAZYCODEX_AUTO_UPDATE_STATE_PATH: statePath,
+			LAZYCODEX_AUTO_UPDATE_LOG_PATH: updateLogPath,
 			LAZYCODEX_AUTO_UPDATE_INTERVAL_MS: "0",
 			LAZYCODEX_AUTO_UPDATE_COMMAND: process.execPath,
 			LAZYCODEX_AUTO_UPDATE_ARGS_JSON: JSON.stringify(["-e", `require("node:fs").writeFileSync(${JSON.stringify(logPath)}, "ok")`]),
@@ -62,6 +64,20 @@ test("#given test command override #when running check #then records state and l
 	assert.equal(result.started, true);
 	assert.equal(JSON.parse(await readFile(statePath, "utf8")).lastCheckedAt, 123_456);
 	assert.equal(await readFile(logPath, "utf8"), "ok");
+	const updateLog = (await readFile(updateLogPath, "utf8")).trim().split("\n").map((line) => JSON.parse(line));
+	assert.deepEqual(updateLog, [
+		{
+			timestamp: "1970-01-01T00:02:03.456Z",
+			event: "started",
+			command: process.execPath,
+			args: ["-e", `require("node:fs").writeFileSync(${JSON.stringify(logPath)}, "ok")`],
+		},
+		{
+			timestamp: "1970-01-01T00:02:03.456Z",
+			event: "finished",
+			status: 0,
+		},
+	]);
 	assert.match(await readFile(join(codexHome, "config.toml"), "utf8"), /model = "gpt-5\.5"/);
 });
 

package/packages/omo-codex/scripts/install/config.mjs

@@ -44,6 +44,8 @@ export async function updateCodexConfig({
 	config = removeStaleManagedAgentBlocks(config, new Set(agentConfigs.map((agentConfig) => agentConfig.name)));
 	config = ensureFeatureEnabled(config, "plugins");
 	config = ensureFeatureEnabled(config, "plugin_hooks");
+	config = ensureFeatureEnabled(config, "multi_agent");
+	config = ensureFeatureEnabled(config, "child_agents_md");
 	config = ensureCodexReasoningConfig(config, await readCodexModelCatalog(repoRoot));
 	config = ensureCodexMultiAgentV2Config(config);
 	if (autonomousPermissions === true) config = ensureAutonomousPermissions(config);

package/packages/omo-codex/scripts/install-config-autonomous-features.test.mjs

@@ -6,7 +6,8 @@ import test from "node:test";
 
 import { updateCodexConfig } from "./install/config.mjs";
 
-const AUTONOMOUS_FEATURES = ["multi_agent", "child_agents_md", "unified_exec", "goals"];
+const ALWAYS_ON_FEATURES = ["plugins", "plugin_hooks", "multi_agent", "child_agents_md"];
+const AUTONOMOUS_PERMISSION_FEATURES = ["unified_exec", "goals"];
 
 test("#given autonomous permissions requested #when script installer updates config #then enables Codex autonomy feature flags", async () => {
 	// given
@@ -39,12 +40,15 @@ test("#given autonomous permissions requested #when script installer updates con
 	// then
 	const content = await readFile(configPath, "utf8");
 	assert.match(content, /network_access = "enabled"/);
-	for (const featureName of AUTONOMOUS_FEATURES) {
+	for (const featureName of ALWAYS_ON_FEATURES) {
+		assert.match(content, new RegExp(`${featureName} = true`));
+	}
+	for (const featureName of AUTONOMOUS_PERMISSION_FEATURES) {
 		assert.match(content, new RegExp(`${featureName} = true`));
 	}
 });
 
-test("#given autonomous permissions disabled #when script installer updates config #then preserves autonomy feature opt-outs", async () => {
+test("#given autonomous permissions disabled #when script installer updates config #then keeps native Codex feature flags enabled", async () => {
 	// given
 	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-autonomous-features-disabled-"));
 	const configPath = join(root, "config.toml");
@@ -75,9 +79,10 @@ test("#given autonomous permissions disabled #when script installer updates conf
 	// then
 	const content = await readFile(configPath, "utf8");
 	assert.match(content, /network_access = "disabled"/);
-	for (const featureName of AUTONOMOUS_FEATURES) {
+	for (const featureName of ALWAYS_ON_FEATURES) {
+		assert.match(content, new RegExp(`${featureName} = true`));
+	}
+	for (const featureName of AUTONOMOUS_PERMISSION_FEATURES) {
 		assert.match(content, new RegExp(`${featureName} = false`));
 	}
-	assert.match(content, /plugins = true/);
-	assert.match(content, /plugin_hooks = true/);
 });