lazycodex-ai 5.0.0-beta.53 → 5.0.0-beta.55

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

@@ -2,7 +2,15 @@ import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 
-export type CodexGoalSnapshotStatus = "active" | "complete" | "cancelled" | "failed" | "unknown";
+export type CodexGoalSnapshotStatus =
+	| "active"
+	| "complete"
+	| "paused"
+	| "usage_limited"
+	| "budget_limited"
+	| "cancelled"
+	| "failed"
+	| "unknown";
 
 export interface CodexGoalSnapshot {
 	available: boolean;
@@ -20,10 +28,7 @@ export interface CodexGoalReconciliation {
 
 export interface ReconcileCodexGoalOptions {
 	expectedObjective: string;
-	acceptedObjectives?: readonly string[];
-	allowedStatuses?: readonly CodexGoalSnapshotStatus[];
-	requireSnapshot?: boolean;
-	requireComplete?: boolean;
+	readonly acceptedObjectives?: readonly string[];
 }
 
 export class CodexGoalSnapshotError extends Error {}
@@ -32,14 +37,21 @@ function safeObject(value: unknown): Record<string, unknown> {
 }
 
 function safeString(value: unknown): string {
+	return typeof value === "string" ? value : "";
+}
+
+function safeStatusString(value: unknown): string {
 	return typeof value === "string" ? value.trim() : "";
 }
 
 function normalizeStatus(value: unknown): CodexGoalSnapshotStatus {
-	const status = safeString(value).toLowerCase();
+	const status = safeStatusString(value).toLowerCase();
 	if (status === "complete" || status === "completed" || status === "done") return "complete";
 	if (status === "cancelled" || status === "canceled") return "cancelled";
 	if (status === "failed" || status === "failure") return "failed";
+	if (status === "paused") return "paused";
+	if (status === "usage_limited") return "usage_limited";
+	if (status === "budget_limited") return "budget_limited";
 	if (status === "active" || status === "in_progress" || status === "pending" || status === "running") return "active";
 	return "unknown";
 }
@@ -100,38 +112,30 @@ export function reconcileCodexGoalSnapshot(
 	const errors: string[] = [];
 	const warnings: string[] = [];
 
+	const expected = options.expectedObjective;
+	const normalizedExpected = normalizeObjective(expected);
 	if (!effectiveSnapshot.available) {
-		const message =
-			"Codex goal snapshot is absent or reports no active goal; call get_goal and pass its JSON with --codex-goal-json.";
-		if (options.requireSnapshot) errors.push(message);
-		else warnings.push(message);
+		warnings.push(`call get_goal; if none, create_goal with codexObjective "${expected}" verbatim`);
 		return { ok: errors.length === 0, snapshot: effectiveSnapshot, warnings, errors };
 	}
 
-	const expected = normalizeObjective(options.expectedObjective);
 	const accepted = new Set(
-		[expected, ...(options.acceptedObjectives ?? []).map((objective) => normalizeObjective(objective))].filter(
-			Boolean,
-		),
+		[
+			normalizedExpected,
+			...(options.acceptedObjectives ?? []).map((objective) => normalizeObjective(objective)),
+		].filter(Boolean),
 	);
 	const actual = normalizeObjective(effectiveSnapshot.objective ?? "");
-	if (!actual) {
-		errors.push("Codex goal snapshot is missing objective text.");
-	} else if (!accepted.has(actual)) {
-		errors.push(`Codex goal objective mismatch: expected "${expected}", got "${actual}".`);
+	if (actual && !accepted.has(normalizeObjective(actual))) {
+		warnings.push(`driver_objective_differs: expected "${expected}", got "${actual}".`);
 	}
 
-	const allowed = options.allowedStatuses ?? (options.requireComplete ? ["complete"] : ["active", "complete"]);
 	const actualStatus = effectiveSnapshot.status ?? "unknown";
-	if (!allowed.includes(actualStatus)) {
-		errors.push(`Codex goal status mismatch: expected ${allowed.join(" or ")}, got ${actualStatus}.`);
-	}
-	if (options.requireComplete && actualStatus !== "complete") {
-		errors.push(
-			'Codex goal is not complete; call update_goal({status: "complete"}) only after the objective is actually complete, then pass the fresh get_goal JSON.',
-		);
+	if (actualStatus === "paused" || actualStatus === "usage_limited" || actualStatus === "budget_limited") {
+		warnings.push("/goal resume or raise the budget");
 	}
-
+	if (actualStatus === "complete")
+		warnings.push(`driver closed early: call create_goal with codexObjective "${expected}" verbatim`);
 	return { ok: errors.length === 0, snapshot: effectiveSnapshot, warnings, errors };
 }
 
@@ -139,26 +143,3 @@ export function formatCodexGoalReconciliation(reconciliation: CodexGoalReconcili
 	const parts = [...reconciliation.errors, ...reconciliation.warnings];
 	return parts.join(" ");
 }
-
-export interface CodexGoalMismatchRecovery {
-	readonly message: string;
-	readonly details: { readonly expectedObjective: string; readonly receivedObjective: string };
-}
-
-/**
- * The reconciliation errors normalize whitespace for comparison, which makes the
- * quoted objective unusable as a copy source. Recovery therefore carries the
- * plan's `codexObjective` verbatim so the agent can paste it into `update_goal`.
- */
-export function codexGoalMismatchRecovery(
-	expectedObjective: string,
-	snapshot: CodexGoalSnapshot | null | undefined,
-): CodexGoalMismatchRecovery {
-	const receivedObjective = snapshot?.objective ?? "";
-	const message = [
-		"Recovery: the Codex goal objective must equal the plan's codexObjective exactly — copy the expected value below into update_goal and re-run get_goal.",
-		`expected codexObjective: ${expectedObjective}`,
-		`received objective: ${receivedObjective || "(none)"}`,
-	].join("\n");
-	return { message, details: { expectedObjective, receivedObjective } };
-}

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

@@ -1,8 +1,12 @@
 // biome-ignore-all format: compact port must stay within the requested pure LOC budget.
 
-import { codexSnapshotMismatchError } from "./checkpoint-reconciliation.js";
-import { readCodexGoalSnapshotInput, reconcileCodexGoalSnapshot } from "./codex-goal-snapshot.js";
-import { codexGoalMode, compatibleCodexObjectives, expectedCodexObjective, isFinalRunCompletionCandidate } from "./goal-status.js";
+import {
+	CodexGoalSnapshotError,
+	formatCodexGoalReconciliation,
+	readCodexGoalSnapshotInput,
+	reconcileCodexGoalSnapshot,
+} from "./codex-goal-snapshot.js";
+import { compatibleCodexObjectives, expectedCodexObjective, isFinalRunCompletionCandidate } from "./goal-status.js";
 import type { UlwLoopScope } from "./paths.js";
 import { seedDefaultSuccessCriteria } from "./plan-crud.js";
 import { appendLedger, readUlwLoopPlan, withUlwLoopMutationLock, writePlan } from "./plan-io.js";
@@ -10,7 +14,14 @@ import type { UlwLoopItem, UlwLoopLedgerEntry, UlwLoopPlan } from "./types.js";
 import { iso, UlwLoopError } from "./types.js";
 
 export interface RecordFinalReviewBlockersArgs { readonly goalId: string; readonly title: string; readonly objective: string; readonly evidence: string; readonly codexGoalJson: string }
-export interface RecordFinalReviewBlockersResult { readonly plan: UlwLoopPlan; readonly blockedGoal: UlwLoopItem; readonly newGoal: UlwLoopItem; readonly ledgerEntries: UlwLoopLedgerEntry[] }
+export interface RecordFinalReviewBlockersResult {
+	readonly plan: UlwLoopPlan;
+	readonly blockedGoal: UlwLoopItem;
+	readonly newGoal: UlwLoopItem;
+	readonly ledgerEntries: UlwLoopLedgerEntry[];
+	readonly nextActions: readonly string[];
+	readonly warnings: readonly string[];
+}
 
 const BLOCKER_FIELDS = "blockedReason blockerSignature blockerOccurrenceCount requiredExternalDecision nonRetriable failedAt failureReason completedAt blocker blockerEvidence blockerOccurrences blockedAt".split(" ");
 
@@ -55,10 +66,11 @@ export async function recordFinalReviewBlockers(
 		if (!isFinalRunCompletionCandidate(plan, goal)) ulwLoopError(`${goal.id} is not final.`, "ulw_loop_not_final_story");
 
 		const snapshot = await readCodexGoalSnapshotInput(args.codexGoalJson, repoRoot);
-		const aggregate = codexGoalMode(plan) === "aggregate";
-		const expected = expectedCodexObjective(plan, goal);
-		const reconciliation = reconcileCodexGoalSnapshot(snapshot, { expectedObjective: expected, ...(aggregate ? { acceptedObjectives: compatibleCodexObjectives(plan) } : {}), allowedStatuses: ["active"], requireSnapshot: true, requireComplete: false });
-		if (!reconciliation.ok) throw codexSnapshotMismatchError({ reconciliation, snapshot, expectedObjective: expected });
+		const reconciliation = reconcileCodexGoalSnapshot(snapshot, {
+			expectedObjective: expectedCodexObjective(plan, goal),
+			acceptedObjectives: compatibleCodexObjectives(plan),
+		});
+		if (!reconciliation.ok) throw new CodexGoalSnapshotError(formatCodexGoalReconciliation(reconciliation));
 
 		const now = iso();
 		for (const field of BLOCKER_FIELDS) Reflect.deleteProperty(goal, field);
@@ -70,7 +82,7 @@ export async function recordFinalReviewBlockers(
 		const newGoal = appendBlockerGoal(plan, args, now);
 		plan.updatedAt = now;
 
-		const codexGoal = reconciliation.snapshot.raw;
+		const codexGoal = snapshot?.raw;
 		const blockedEntry: UlwLoopLedgerEntry = { at: now, kind: "goal_review_blocked", goalId: goal.id, status: goal.status, evidence: args.evidence, codexGoal };
 		const addedEntry: UlwLoopLedgerEntry = { at: now, kind: "goal_added", goalId: newGoal.id, status: newGoal.status, evidence: args.evidence, message: newGoal.title };
 		const summaryEntry: UlwLoopLedgerEntry = { at: now, kind: "goal_review_blocked", goalId: goal.id, status: goal.status, evidence: args.evidence, codexGoal, message: `Review blockers recorded; appended ${newGoal.id}.` };
@@ -78,6 +90,13 @@ export async function recordFinalReviewBlockers(
 		const ledgerEntries = [blockedEntry, addedEntry, summaryEntry];
 		await writePlan(repoRoot, plan, scope);
 		for (const entry of ledgerEntries) await appendLedger(repoRoot, entry, scope);
-		return { plan, blockedGoal: goal, newGoal, ledgerEntries };
+		return {
+			plan,
+			blockedGoal: goal,
+			newGoal,
+			ledgerEntries,
+			nextActions: reconciliation.warnings,
+			warnings: reconciliation.warnings.filter((warning) => warning.startsWith("driver_objective_differs")),
+		};
 	});
 }

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

@@ -1,9 +1,6 @@
-import { writeFile } from "node:fs/promises";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
 
 import { checkpointUlwLoop } from "../src/checkpoint.js";
-import { ulwLoopBriefPath } from "../src/paths.js";
-import { startNextUlwLoop } from "../src/plan-crud.js";
 import { criterion, expectCode, goal, passGoal, plan, repoWith, snapshot } from "./fixtures/checkpoint-builders.js";
 import { MISSING_ARTIFACT_PATH, qualityGateJson } from "./fixtures/quality-gate-builder.js";
 
@@ -134,7 +131,6 @@ describe("checkpointUlwLoop final story", () => {
 		} catch (error) {
 			expect(error).toBeInstanceOf(Error);
 			if (!(error instanceof Error)) throw error;
-			expect(error.message).toContain("Codex goal objective mismatch");
 			expect(error.message).toContain("manualQa.surfaceEvidence");
 			expect(error.message).toContain("gateReview.recommendation");
 		}
@@ -216,84 +212,6 @@ describe("checkpointUlwLoop final story", () => {
 		);
 	});
 
-	it("ACCEPTS complete when task-scoped completed Codex objective maps to the ulw-loop brief", async () => {
-		const taskObjective = "Fix ulw-loop objective mismatch and install local ulw";
-		const repo = await repoWith(plan([passGoal("G001")], { activeGoalId: "G001" }));
-		await writeFile(ulwLoopBriefPath(repo), `${taskObjective}\n`, "utf8");
-
-		const result = await checkpointUlwLoop(repo, {
-			goalId: "G001",
-			status: "complete",
-			evidence: "final implementation complete and quality gate passed",
-			codexGoalJson: snapshot("complete", taskObjective),
-			qualityGateJson: await qualityGateJson(repo),
-		});
-
-		expect(result.aggregateCompletion?.status).toBe("complete");
-		expect(result.ledgerEntry.kind).toBe("aggregate_completed");
-	});
-
-	it("ACCEPTS complete when active task-scoped Codex objective maps to the ulw-loop brief", async () => {
-		const taskObjective = "Create only research artifacts with source evidence";
-		const repo = await repoWith(plan([passGoal("G001")], { activeGoalId: "G001" }));
-		await writeFile(ulwLoopBriefPath(repo), `${taskObjective}\n`, "utf8");
-
-		const result = await checkpointUlwLoop(repo, {
-			goalId: "G001",
-			status: "complete",
-			evidence: "final implementation complete and quality gate passed",
-			codexGoalJson: snapshot("active", taskObjective),
-			qualityGateJson: await qualityGateJson(repo),
-		});
-
-		expect(result.aggregateCompletion?.status).toBe("complete");
-		expect(result.ledgerEntry.kind).toBe("aggregate_completed");
-	});
-
-	it("explains final task-scoped objective mapping when completed Codex objective is unrelated", async () => {
-		const repo = await repoWith(plan([passGoal("G001")], { activeGoalId: "G001" }));
-		await writeFile(ulwLoopBriefPath(repo), "Fix ulw-loop objective mismatch and install local ulw\n", "utf8");
-
-		await expect(
-			checkpointUlwLoop(repo, {
-				goalId: "G001",
-				status: "complete",
-				evidence: "final implementation complete and quality gate passed",
-				codexGoalJson: snapshot("complete", "unrelated completed task"),
-				qualityGateJson: await qualityGateJson(repo),
-			}),
-		).rejects.toThrow("Final task-scoped aggregate reconciliation");
-	});
-
-	it("keeps aggregate open when non-final task-scoped Codex completion maps to the brief", async () => {
-		const taskObjective = "Implement first accepted story";
-		const first = goal({
-			id: "G001",
-			status: "in_progress",
-			successCriteria: [
-				criterion("C001", "pass", { essential: true }),
-				criterion("C002", "pending", { essential: false }),
-			],
-		});
-		const second = goal({ id: "G002", status: "pending", objective: "Implement second accepted story" });
-		const repo = await repoWith(plan([first, second], { activeGoalId: "G001" }));
-		await writeFile(ulwLoopBriefPath(repo), `${taskObjective}\n`, "utf8");
-
-		const result = await checkpointUlwLoop(repo, {
-			goalId: "G001",
-			status: "complete",
-			evidence: "G001 updated .omo/ulw-loop/goals.json after implementation completed and validation passed",
-			codexGoalJson: snapshot("complete", taskObjective),
-			qualityGateJson: await qualityGateJson(repo),
-		});
-		const next = await startNextUlwLoop(repo);
-
-		expect(result.aggregateCompletion).toBeUndefined();
-		expect(result.plan.aggregateCompletion).toBeUndefined();
-		expect(result.ledgerEntry.kind).toBe("goal_completed");
-		expect(next).toMatchObject({ goal: { id: "G002", status: "in_progress" } });
-	});
-
 	it("requires all criteria for per-story completion", async () => {
 		const current = goal({
 			successCriteria: [

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

@@ -127,33 +127,27 @@ describe("checkpointUlwLoop reconciliation (status=complete)", () => {
 		).resolves.toMatchObject({ goal: { status: "complete" } });
 	});
 
-	it("throws on mismatched objective", async () => {
+	it("warns when objective mismatches", async () => {
 		const repo = await repoWith(plan([passGoal("G001"), goal({ id: "G002", status: "pending" })]));
 
-		await expectCode(
-			() =>
-				checkpointUlwLoop(repo, {
-					goalId: "G001",
-					status: "complete",
-					evidence: "work complete and validation passed",
-					codexGoalJson: snapshot("active", "wrong objective"),
-				}),
-			"ulw_loop_codex_snapshot_mismatch",
-		);
+		const result = await checkpointUlwLoop(repo, {
+			goalId: "G001",
+			status: "complete",
+			evidence: "work complete and validation passed",
+			codexGoalJson: snapshot("active", "wrong objective"),
+		});
+		expect(result.warnings.join(" ")).toContain("driver_objective_differs");
 	});
 
-	it("throws on mismatched status (snapshot complete when expected active)", async () => {
+	it("advises create_goal when the driver closed early", async () => {
 		const repo = await repoWith(plan([passGoal("G001"), goal({ id: "G002", status: "pending" })]));
 
-		await expectCode(
-			() =>
-				checkpointUlwLoop(repo, {
-					goalId: "G001",
-					status: "complete",
-					evidence: "work complete and validation passed",
-					codexGoalJson: snapshot("complete"),
-				}),
-			"ulw_loop_codex_snapshot_mismatch",
-		);
+		const result = await checkpointUlwLoop(repo, {
+			goalId: "G001",
+			status: "complete",
+			evidence: "work complete and validation passed",
+			codexGoalJson: snapshot("complete"),
+		});
+		expect(result.nextActions.join(" ")).toContain("create_goal");
 	});
 });

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

@@ -128,6 +128,33 @@ describe("ulwLoopCommand checkpoint", () => {
 		expect(stdoutJson()).toHaveProperty("goal.status", "complete");
 	});
 
+	it("#given a complete checkpoint with an objective difference #when invoked with JSON #then exposes driver advice and warning", async () => {
+		await createPlan();
+		await passCriterion("G001-goal-a", "C001");
+		await passCriterion("G001-goal-a", "C002");
+		await passCriterion("G001-goal-a", "C003");
+
+		expect(
+			await ulwLoopCommand([
+				"checkpoint",
+				"--goal-id",
+				"G001-goal-a",
+				"--status",
+				"complete",
+				"--evidence",
+				"implementation done and validation passed",
+				"--codex-goal-json",
+				JSON.stringify({ goal: { objective: "different driver", status: "budget_limited" } }),
+				"--json",
+			]),
+		).toBe(0);
+		const result = stdoutJson();
+		expect(result).toMatchObject({ ok: true });
+		expect(result).toHaveProperty("nextActions");
+		expect(JSON.stringify(result)).toContain("driver_objective_differs");
+		expect(JSON.stringify(result)).toContain("/goal resume");
+	});
+
 	it("ACCEPTS when all criteria pass", async () => {
 		await createPlan();
 		await passCriterion("G001-goal-a", "C001");

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

@@ -78,6 +78,31 @@ describe("ulwLoopCommand --json error contract", () => {
 		expect(stdoutJson()).toMatchObject({ ok: false, error: { code: expect.any(String) } });
 	});
 
+	it("#given an invalid codex snapshot token #when checkpoint --json #then emits the stable typed error", async () => {
+		const code = await ulwLoopCommand([
+			"checkpoint",
+			"--json",
+			"--goal-id",
+			"G001",
+			"--status",
+			"complete",
+			"--evidence",
+			"proof",
+			"--codex-goal-json",
+			"not-json-not-a-path",
+		]);
+
+		expect(code).toBe(1);
+		expect(err.join("")).toBe("");
+		expect(stdoutJson()).toMatchObject({
+			ok: false,
+			error: {
+				code: "ULW_LOOP_CODEX_GOAL_JSON_INVALID",
+				message: expect.stringContaining("neither valid JSON nor a readable path"),
+			},
+		});
+	});
+
 	it("#given a malformed required flag #when --json #then surfaces the UlwLoopError code with details on stdout", async () => {
 		const code = await ulwLoopCommand(["criteria", "--json"]);
 

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

@@ -103,10 +103,10 @@ describe("readCodexGoalSnapshotInput", () => {
 
 	it("reads from sample fixture path", async () => {
 		// given
-		const filePath = join(process.cwd(), "test", "fixtures", "codex-goal-snapshot.json");
+		const filePath = new URL("./fixtures/codex-goal-snapshot.json", import.meta.url);
 
 		// when
-		const snapshot = await readCodexGoalSnapshotInput(filePath);
+		const snapshot = await readCodexGoalSnapshotInput(filePath.pathname);
 
 		// then
 		expect(snapshot?.available).toBe(true);
@@ -120,6 +120,15 @@ describe("readCodexGoalSnapshotInput", () => {
 });
 
 describe("reconcileCodexGoalSnapshot", () => {
+	it("preserves objective whitespace in driver advice while normalizing comparison", () => {
+		const expectedObjective = "  exact   objective\nwith spacing  ";
+		const result = reconcileCodexGoalSnapshot(
+			parseCodexGoalSnapshot({ goal: { objective: "different", status: "active" } }),
+			{ expectedObjective },
+		);
+
+		expect(result.warnings[0]).toContain(`expected "${expectedObjective}"`);
+	});
 	it("returns ok=true when snapshot matches expected", () => {
 		// when
 		const reconciliation = reconcileCodexGoalSnapshot(
@@ -132,7 +141,7 @@ describe("reconcileCodexGoalSnapshot", () => {
 		expect(reconciliation.errors).toHaveLength(0);
 	});
 
-	it("reports error when objective mismatches", () => {
+	it("reports warning when objective mismatches", () => {
 		// when
 		const reconciliation = reconcileCodexGoalSnapshot(
 			{ available: true, objective: "X", status: "active", raw: null },
@@ -140,20 +149,34 @@ describe("reconcileCodexGoalSnapshot", () => {
 		);
 
 		// then
-		expect(reconciliation.ok).toBe(false);
-		expect(reconciliation.errors.length).toBeGreaterThan(0);
+		expect(reconciliation.ok).toBe(true);
+		expect(reconciliation.errors).toHaveLength(0);
+		expect(reconciliation.warnings.join(" ")).toContain("driver_objective_differs");
 	});
 
-	it("reports error when status mismatches", () => {
+	it("accepts a parsable snapshot without objective as advisory", () => {
 		// when
 		const reconciliation = reconcileCodexGoalSnapshot(
-			{ available: true, objective: "X", status: "active", raw: null },
-			{ expectedObjective: "X", allowedStatuses: ["complete"] },
+			{ available: true, status: "active", raw: { goal: { status: "active" } } },
+			{ expectedObjective: "X" },
 		);
 
 		// then
-		expect(reconciliation.ok).toBe(false);
-		expect(reconciliation.errors.length).toBeGreaterThan(0);
+		expect(reconciliation.ok).toBe(true);
+		expect(reconciliation.errors).toHaveLength(0);
+	});
+
+	it("accepts limited driver statuses", () => {
+		// when
+		const reconciliation = reconcileCodexGoalSnapshot(
+			{ available: true, objective: "X", status: "budget_limited", raw: null },
+			{ expectedObjective: "X" },
+		);
+
+		// then
+		expect(reconciliation.ok).toBe(true);
+		expect(reconciliation.errors).toHaveLength(0);
+		expect(reconciliation.warnings.join(" ")).toContain("/goal resume");
 	});
 });
 
@@ -162,7 +185,7 @@ describe("formatCodexGoalReconciliation", () => {
 		// given
 		const reconciliation = reconcileCodexGoalSnapshot(
 			{ available: true, objective: "X", status: "active", raw: null },
-			{ expectedObjective: "Y", allowedStatuses: ["complete"] },
+			{ expectedObjective: "Y" },
 		);
 
 		// when

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

@@ -4,12 +4,10 @@ import { join } from "node:path";
 import { describe, expect, it } from "vitest";
 
 import { checkpointUlwLoop } from "../src/checkpoint.js";
-import { ULW_LOOP_AGGREGATE_CODEX_OBJECTIVE } from "../src/goal-status.js";
 import { ulwLoopDir } from "../src/paths.js";
 import { readUlwLoopPlan } from "../src/plan-io.js";
-import { recordFinalReviewBlockers } from "../src/review-blockers.js";
 import { UlwLoopError } from "../src/types.js";
-import { goal, passGoal, plan, repoWith, snapshot } from "./fixtures/checkpoint-builders.js";
+import { goal, passGoal, plan, repoWith } from "./fixtures/checkpoint-builders.js";
 
 async function captureError(action: () => Promise<unknown>): Promise<UlwLoopError> {
 	try {
@@ -23,52 +21,16 @@ async function captureError(action: () => Promise<unknown>): Promise<UlwLoopErro
 }
 
 describe("#given a codex goal snapshot whose objective differs from the plan", () => {
-	it("#when checkpoint reconciles it #then the mismatch carries the verbatim expected and received objectives", async () => {
+	it("#when checkpoint reconciles it #then it succeeds with driver advice", async () => {
 		const repo = await repoWith(plan([passGoal("G001"), goal({ id: "G002", status: "pending" })]));
-
-		const error = await captureError(() =>
-			checkpointUlwLoop(repo, {
-				goalId: "G001",
-				status: "complete",
-				evidence: "work complete and validation passed",
-				codexGoalJson: snapshot("active", "wrong objective"),
-			}),
-		);
-
-		expect(error.code).toBe("ulw_loop_codex_snapshot_mismatch");
-		expect(error.details).toMatchObject({
-			expectedObjective: ULW_LOOP_AGGREGATE_CODEX_OBJECTIVE,
-			receivedObjective: "wrong objective",
-		});
-		expect(error.message).toContain(
-			"objective must equal the plan's codexObjective exactly — copy the expected value below",
-		);
-		expect(error.message).toContain(ULW_LOOP_AGGREGATE_CODEX_OBJECTIVE);
-	});
-
-	it("#when record-review-blockers reconciles it #then the same guided payload is emitted", async () => {
-		const repo = await repoWith(
-			plan([passGoal("G001", { status: "complete" }), goal({ id: "G002", status: "in_progress" })]),
-		);
-
-		const error = await captureError(() =>
-			recordFinalReviewBlockers(repo, {
-				goalId: "G002",
-				title: "Resolve final review blockers",
-				objective: "Address the BLOCK findings",
-				evidence: "review verdict: REQUEST_CHANGES",
-				codexGoalJson: JSON.stringify({ goal: { objective: "stale objective", status: "active" } }),
-			}),
-		);
-
-		expect(error.code).toBe("ulw_loop_codex_snapshot_mismatch");
-		expect(error.details).toMatchObject({
-			expectedObjective: ULW_LOOP_AGGREGATE_CODEX_OBJECTIVE,
-			receivedObjective: "stale objective",
+		const result = await checkpointUlwLoop(repo, {
+			goalId: "G001",
+			status: "complete",
+			evidence: "work complete",
+			codexGoalJson: JSON.stringify({ goal: { objective: "wrong objective", status: "budget_limited" } }),
 		});
-		expect(error.message).toContain(
-			"objective must equal the plan's codexObjective exactly — copy the expected value below",
-		);
+		expect(result.nextActions.join(" ")).toContain("/goal resume");
+		expect(result.warnings.join(" ")).toContain("driver_objective_differs");
 	});
 });
 

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

@@ -157,15 +157,17 @@ describe("recordFinalReviewBlockers error cases", () => {
 			"ulw_loop_not_final_story",
 		);
 	});
+});
 
-	it("throws ulw_loop_codex_snapshot_mismatch when objective mismatches", async () => {
+describe("recordFinalReviewBlockers advisory results", () => {
+	it("returns objective-difference warning and resume action for a limited snapshot", 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",
-		);
+		const result = await recordFinalReviewBlockers(repo, {
+			...validArgs,
+			codexGoalJson: JSON.stringify({ goal: { objective: "different", status: "budget_limited" } }),
+		});
+		expect(result.nextActions).toContain("/goal resume or raise the budget");
+		expect(result.warnings.some((warning) => warning.startsWith("driver_objective_differs"))).toBe(true);
 	});
 });
 

package/packages/omo-codex/plugin/hooks/post-compact-resetting-git-bash-mcp-reminder.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/git-bash/dist/cli.js\" hook post-compact",
 						"timeout": 5,
-						"statusMessage": "(OmO 5.0.0-beta.53) Resetting Git Bash MCP Reminder",
+						"statusMessage": "(OmO 5.0.0-beta.55) Resetting Git Bash MCP Reminder",
 						"commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -File \"${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\node-dispatch.ps1\" \"${PLUGIN_ROOT}\\components\\git-bash\\dist\\cli.js\" hook post-compact"
 					}
 				],

package/packages/omo-codex/plugin/hooks/post-compact-resetting-lsp-diagnostics-cache.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/lsp/dist/cli.js\" hook post-compact",
 						"timeout": 5,
-						"statusMessage": "(OmO 5.0.0-beta.53) Resetting LSP Diagnostics Cache",
+						"statusMessage": "(OmO 5.0.0-beta.55) Resetting LSP Diagnostics Cache",
 						"commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -File \"${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\node-dispatch.ps1\" \"${PLUGIN_ROOT}\\components\\lsp\\dist\\cli.js\" hook post-compact"
 					}
 				],

package/packages/omo-codex/plugin/hooks/post-compact-resetting-project-rule-cache.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/rules/dist/cli.js\" hook post-compact",
 						"timeout": 10,
-						"statusMessage": "(OmO 5.0.0-beta.53) Resetting Project Rule Cache",
+						"statusMessage": "(OmO 5.0.0-beta.55) Resetting Project Rule Cache",
 						"commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -File \"${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\node-dispatch.ps1\" \"${PLUGIN_ROOT}\\components\\rules\\dist\\cli.js\" hook post-compact"
 					}
 				],

package/packages/omo-codex/plugin/hooks/post-tool-use-checking-comments.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/comment-checker/dist/cli.js\" hook post-tool-use",
 						"timeout": 30,
-						"statusMessage": "(OmO 5.0.0-beta.53) Checking Comments",
+						"statusMessage": "(OmO 5.0.0-beta.55) Checking Comments",
 						"commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -File \"${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\node-dispatch.ps1\" \"${PLUGIN_ROOT}\\components\\comment-checker\\dist\\cli.js\" hook post-tool-use"
 					}
 				],