lazycodex-ai 5.0.0-beta.63 → 5.0.0-beta.65

package/packages/omo-codex/plugin/components/ulw-loop/dist/success-criteria-input.js

@@ -0,0 +1,41 @@
+import { ULW_LOOP_SUCCESS_CRITERION_USER_MODELS, UlwLoopError } from "./types.js";
+function invalid(message, details) {
+    throw new UlwLoopError(`Invalid successCriteria: ${message}`, "ULW_LOOP_ARGUMENT_INVALID", { details });
+}
+function isUserModel(value) {
+    return typeof value === "string" && ULW_LOOP_SUCCESS_CRITERION_USER_MODELS.some((model) => model === value);
+}
+function requireText(value, field, index) {
+    const trimmed = typeof value === "string" ? value.trim() : "";
+    return trimmed || invalid(`entry ${index + 1} needs a non-empty ${field}.`, { index, field });
+}
+export function criterionId(index) {
+    return `C${String(index + 1).padStart(3, "0")}`;
+}
+export function criteriaFromInput(input) {
+    if (input.length === 0)
+        invalid("provide at least one criterion or omit the field for placeholders.", { count: 0 });
+    return input.map((entry, index) => {
+        if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+            return invalid(`entry ${index + 1} must be an object.`, { index });
+        const record = { ...entry };
+        const userModel = record["userModel"] ?? "happy";
+        if (!isUserModel(userModel))
+            return invalid(`entry ${index + 1} userModel must be one of ${ULW_LOOP_SUCCESS_CRITERION_USER_MODELS.join(", ")}.`, {
+                index,
+                userModel: String(userModel),
+            });
+        const essential = record["essential"];
+        if (essential !== undefined && typeof essential !== "boolean")
+            return invalid(`entry ${index + 1} essential must be a boolean.`, { index });
+        return {
+            id: criterionId(index),
+            scenario: requireText(record["scenario"], "scenario", index),
+            userModel,
+            expectedEvidence: requireText(record["expectedEvidence"], "expectedEvidence", index),
+            essential: essential ?? true,
+            capturedEvidence: null,
+            status: "pending",
+        };
+    });
+}

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

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook user-prompt-submit --with-ultrawork",
 						"timeout": 10,
-						"statusMessage": "(OmO 5.0.0-beta.63) Checking Ulw-Loop Steering"
+						"statusMessage": "(OmO 5.0.0-beta.65) Checking Ulw-Loop Steering"
 					}
 				]
 			}
@@ -20,7 +20,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-tool-use-spawn",
 						"timeout": 5,
-						"statusMessage": "(OmO 5.0.0-beta.63) Recording Spawn Admission"
+						"statusMessage": "(OmO 5.0.0-beta.65) Recording Spawn Admission"
 					}
 				]
 			}
@@ -33,7 +33,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook pre-tool-use",
 						"timeout": 5,
-						"statusMessage": "(OmO 5.0.0-beta.63) Enforcing Unlimited Ulw-Loop Budget"
+						"statusMessage": "(OmO 5.0.0-beta.65) Enforcing Unlimited Ulw-Loop Budget"
 					}
 				]
 			},
@@ -44,7 +44,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook pre-tool-use-spawn",
 						"timeout": 5,
-						"statusMessage": "(OmO 5.0.0-beta.63) Guarding Ulw-Loop Spawns"
+						"statusMessage": "(OmO 5.0.0-beta.65) Guarding Ulw-Loop Spawns"
 					}
 				]
 			}
@@ -56,7 +56,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook stop",
 						"timeout": 10,
-						"statusMessage": "(OmO 5.0.0-beta.63) Checking Ulw-Loop Resume"
+						"statusMessage": "(OmO 5.0.0-beta.65) Checking Ulw-Loop Resume"
 					}
 				]
 			}

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

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-ulw-loop",
-	"version": "5.0.0-beta.63",
+	"version": "5.0.0-beta.65",
 	"description": "Codex plugin: durable repo-native multi-goal orchestration with embedded success criteria and observable evidence audit.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",

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

@@ -4,11 +4,19 @@ import {
 	readCodexGoalSnapshotInput,
 	reconcileCodexGoalSnapshot,
 } from "./codex-goal-snapshot.js";
+import { acknowledgedDriverObjectives } from "./driver-objective-ack.js";
 import { codexGoalMode, compatibleCodexObjectives, expectedCodexObjective } from "./goal-status.js";
 import type { UlwLoopScope } from "./paths.js";
 import type { UlwLoopItem, UlwLoopPlan } from "./types.js";
 import { UlwLoopError } from "./types.js";
 
+export interface CheckpointCodexGoalValidation {
+	readonly raw: unknown;
+	readonly nextActions: readonly string[];
+	readonly warnings: readonly string[];
+	readonly unacknowledgedObjective?: string;
+}
+
 export async function validateCheckpointCodexGoal(input: {
 	readonly repoRoot: string;
 	readonly plan: UlwLoopPlan;
@@ -16,11 +24,12 @@ export async function validateCheckpointCodexGoal(input: {
 	readonly raw: string | undefined;
 	readonly evidence: string;
 	readonly scope?: UlwLoopScope;
-}): Promise<{ readonly raw: unknown; readonly nextActions: readonly string[]; readonly warnings: readonly string[] }> {
+}): Promise<CheckpointCodexGoalValidation> {
 	const snapshot = await readCodexGoalSnapshotInput(input.raw, input.repoRoot);
 	const expected = expectedCodexObjective(input.plan, input.goal);
 	const reconciliation = reconcileCodexGoalSnapshot(snapshot, {
 		expectedObjective: expected,
+		acknowledgedObjectives: acknowledgedDriverObjectives(input.plan),
 		...(codexGoalMode(input.plan) === "aggregate"
 			? { acceptedObjectives: compatibleCodexObjectives(input.plan) }
 			: {}),
@@ -28,8 +37,11 @@ export async function validateCheckpointCodexGoal(input: {
 	if (!reconciliation.ok) throw new CodexGoalSnapshotError(formatCodexGoalReconciliation(reconciliation));
 	return {
 		raw: snapshot?.raw,
-		nextActions: reconciliation.warnings,
-		warnings: reconciliation.warnings.filter((warning) => warning.startsWith("driver_objective_differs")),
+		nextActions: reconciliation.nextActions,
+		warnings: reconciliation.warnings,
+		...(reconciliation.unacknowledgedObjective === undefined
+			? {}
+			: { unacknowledgedObjective: reconciliation.unacknowledgedObjective }),
 	};
 }
 

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

@@ -6,6 +6,7 @@ import {
 	combineCheckpointValidationErrors,
 	validateCheckpointCodexGoal,
 } from "./checkpoint-codex-validation.js";
+import { acknowledgeDriverObjective } from "./driver-objective-ack.js";
 import { requireAllCriteriaPass, requireAllPlanCriteriaPass, requireEssentialCriteriaPass } from "./evidence.js";
 import { codexGoalMode, isFinalRunCompletionCandidate } from "./goal-status.js";
 import type { UlwLoopScope } from "./paths.js";
@@ -190,6 +191,7 @@ export async function checkpointUlwLoop(
 				codexGoal = validation.raw;
 				nextActions = validation.nextActions;
 				warnings = validation.warnings;
+				acknowledgeDriverObjective(plan, validation.unacknowledgedObjective);
 			} catch (error) {
 				if (!(error instanceof UlwLoopError)) throw error;
 				codexValidationError = error;

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

@@ -22,13 +22,19 @@ export interface CodexGoalSnapshot {
 export interface CodexGoalReconciliation {
 	ok: boolean;
 	snapshot: CodexGoalSnapshot;
+	/** Facts to know (a differing driver objective); never something to do. */
 	warnings: string[];
+	/** Things to do next (create, re-create, or resume the driver goal). */
+	nextActions: string[];
 	errors: string[];
+	/** The differing objective this reconciliation reported for the first time, for the caller to acknowledge. */
+	unacknowledgedObjective?: string;
 }
 
 export interface ReconcileCodexGoalOptions {
 	expectedObjective: string;
 	readonly acceptedObjectives?: readonly string[];
+	readonly acknowledgedObjectives?: readonly string[];
 }
 
 export class CodexGoalSnapshotError extends Error {}
@@ -111,35 +117,41 @@ export function reconcileCodexGoalSnapshot(
 	const effectiveSnapshot = snapshot ?? { available: false, raw: null };
 	const errors: string[] = [];
 	const warnings: string[] = [];
+	const nextActions: string[] = [];
 
 	const expected = options.expectedObjective;
-	const normalizedExpected = normalizeObjective(expected);
 	if (!effectiveSnapshot.available) {
-		warnings.push(`call get_goal; if none, create_goal with codexObjective "${expected}" verbatim`);
-		return { ok: errors.length === 0, snapshot: effectiveSnapshot, warnings, errors };
+		nextActions.push(`call get_goal; if none, create_goal with codexObjective "${expected}" verbatim`);
+		return { ok: errors.length === 0, snapshot: effectiveSnapshot, warnings, nextActions, errors };
 	}
 
-	const accepted = new Set(
-		[
-			normalizedExpected,
-			...(options.acceptedObjectives ?? []).map((objective) => normalizeObjective(objective)),
-		].filter(Boolean),
-	);
+	const normalized = (objectives: readonly string[]) => new Set(objectives.map(normalizeObjective).filter(Boolean));
+	const accepted = normalized([expected, ...(options.acceptedObjectives ?? [])]);
+	const acknowledged = normalized(options.acknowledgedObjectives ?? []);
 	const actual = normalizeObjective(effectiveSnapshot.objective ?? "");
-	if (actual && !accepted.has(normalizeObjective(actual))) {
+	let unacknowledgedObjective: string | undefined;
+	if (actual && !accepted.has(actual) && !acknowledged.has(actual)) {
 		warnings.push(`driver_objective_differs: expected "${expected}", got "${actual}".`);
+		unacknowledgedObjective = actual;
 	}
 
 	const actualStatus = effectiveSnapshot.status ?? "unknown";
 	if (actualStatus === "paused" || actualStatus === "usage_limited" || actualStatus === "budget_limited") {
-		warnings.push("/goal resume or raise the budget");
+		nextActions.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 };
+		nextActions.push(`driver closed early: call create_goal with codexObjective "${expected}" verbatim`);
+	return {
+		ok: errors.length === 0,
+		snapshot: effectiveSnapshot,
+		warnings,
+		nextActions,
+		errors,
+		...(unacknowledgedObjective === undefined ? {} : { unacknowledgedObjective }),
+	};
 }
 
 export function formatCodexGoalReconciliation(reconciliation: CodexGoalReconciliation): string {
-	const parts = [...reconciliation.errors, ...reconciliation.warnings];
+	const parts = [...reconciliation.errors, ...reconciliation.nextActions, ...reconciliation.warnings];
 	return parts.join(" ");
 }

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

@@ -19,6 +19,7 @@ export interface UlwLoopSuccessCriterion {
 	status: UlwLoopCriterionStatus;
 	capturedAt?: string;
 	notes?: string;
+	artifacts?: string[];
 }
 
 export interface UlwLoopItem {
@@ -75,6 +76,7 @@ export interface UlwLoopPlan {
 	codexGoalMode?: UlwLoopCodexGoalMode;
 	codexObjective?: string;
 	codexObjectiveAliases?: string[];
+	acknowledgedDriverObjectives?: string[];
 	aggregateCompletion?: UlwLoopAggregateCompletion;
 	activeGoalId?: string;
 	validationBatches?: readonly UlwLoopValidationBatch[];
@@ -173,6 +175,7 @@ export interface UlwLoopLedgerEntry {
 	codexGoal?: unknown;
 	evidence?: string;
 	capturedEvidence?: string;
+	artifacts?: string[];
 	qualityGate?: unknown;
 	steering?: UlwLoopSteeringAudit;
 	before?: unknown;

package/packages/omo-codex/plugin/components/ulw-loop/src/driver-objective-ack.ts

@@ -0,0 +1,20 @@
+import type { UlwLoopPlan } from "./types.js";
+
+export function normalizeDriverObjective(value: string): string {
+	return value.replace(/\s+/g, " ").trim();
+}
+
+export function acknowledgedDriverObjectives(plan: UlwLoopPlan): readonly string[] {
+	return plan.acknowledgedDriverObjectives ?? [];
+}
+
+// A differing driver objective is reported once; the plan remembers the exact text so every later
+// checkpoint under the same driver stays quiet, while a driver rewritten to a third objective is
+// reported again.
+export function acknowledgeDriverObjective(plan: UlwLoopPlan, objective: string | undefined): boolean {
+	if (objective === undefined) return false;
+	const normalized = normalizeDriverObjective(objective);
+	if (!normalized || acknowledgedDriverObjectives(plan).includes(normalized)) return false;
+	plan.acknowledgedDriverObjectives = [...acknowledgedDriverObjectives(plan), normalized];
+	return true;
+}

package/packages/omo-codex/plugin/components/ulw-loop/src/evidence-artifacts.ts

@@ -0,0 +1,45 @@
+import { existsSync } from "node:fs";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { UlwLoopError } from "./types.js";
+
+function fail(message: string, code: string, details: Record<string, unknown>): never {
+	throw new UlwLoopError(message, code, { details });
+}
+
+function stored(repoRoot: string, absolute: string): string {
+	const rel = relative(repoRoot, absolute);
+	const inside = rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+	return inside ? rel.split(sep).join("/") : absolute;
+}
+
+// Artifacts are bound at record time: a cited path that does not exist is a claim without a file,
+// so the whole record is refused before any state changes. Paths inside the session cwd persist
+// repo-relative (portable across machines); paths outside persist absolute.
+export function resolveEvidenceArtifacts(
+	repoRoot: string,
+	artifacts: readonly unknown[] | undefined,
+): string[] | undefined {
+	if (artifacts === undefined) return undefined;
+	const seen = new Set<string>();
+	const resolved: string[] = [];
+	for (const [index, candidate] of artifacts.entries()) {
+		const path = typeof candidate === "string" ? candidate.trim() : "";
+		if (!path) fail(`Artifact ${index + 1} must be a non-empty path.`, "ULW_LOOP_ARGUMENT_INVALID", { index });
+		const absolute = resolve(repoRoot, path);
+		if (!existsSync(absolute))
+			fail(
+				`Evidence artifact does not exist: ${path} (resolved to ${absolute}).`,
+				"ULW_LOOP_EVIDENCE_ARTIFACT_MISSING",
+				{
+					path,
+					resolved: absolute,
+				},
+			);
+		const value = stored(repoRoot, absolute);
+		if (!seen.has(value)) {
+			seen.add(value);
+			resolved.push(value);
+		}
+	}
+	return resolved;
+}

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

@@ -1,3 +1,4 @@
+import { resolveEvidenceArtifacts } from "./evidence-artifacts.js";
 import { essentialCriteriaOf, hasAllCriteriaPass, hasEssentialCriteriaPass } from "./goal-status.js";
 import type { UlwLoopScope } from "./paths.js";
 import { commit } from "./plan-commit.js";
@@ -12,6 +13,7 @@ type RecordEvidenceArgs = {
 	readonly status: EvidenceStatus;
 	readonly evidence: string;
 	readonly notes?: string;
+	readonly artifacts?: readonly string[];
 };
 
 function ulwLoopFail(message: string, code: string, details: Record<string, unknown>): never {
@@ -67,6 +69,7 @@ export async function recordEvidence(
 		const goal = findGoal(plan, args.goalId);
 		const criterion = findCriterion(goal, args.criterionId);
 		const evidence = nonEmptyEvidence(args.evidence);
+		const artifacts = resolveEvidenceArtifacts(repoRoot, args.artifacts);
 		const kind = ledgerKind(args.status);
 		const prevStatus = criterion.status;
 		const capturedAt = iso();
@@ -74,6 +77,8 @@ export async function recordEvidence(
 		criterion.capturedEvidence = evidence;
 		criterion.capturedAt = capturedAt;
 		if (args.notes !== undefined) criterion.notes = args.notes;
+		if (artifacts !== undefined) criterion.artifacts = artifacts;
+		else delete criterion.artifacts;
 		goal.updatedAt = capturedAt;
 		plan.updatedAt = capturedAt;
 		const ledgerEntry: UlwLoopLedgerEntry = {
@@ -84,6 +89,7 @@ export async function recordEvidence(
 			criterionStatus: args.status,
 			evidence,
 			capturedEvidence: evidence,
+			...(artifacts === undefined ? {} : { artifacts }),
 			before: { status: prevStatus },
 			after: { goalId: goal.id, criterionId: criterion.id, status: args.status, evidence, capturedAt, prevStatus },
 		};
@@ -112,6 +118,7 @@ export async function markCriteriaPendingResetForGoal(
 			criterion.capturedEvidence = null;
 			delete criterion.capturedAt;
 			delete criterion.notes;
+			delete criterion.artifacts;
 		}
 		goal.updatedAt = now;
 		plan.updatedAt = now;

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

@@ -85,6 +85,13 @@ export function repoRelative(absolutePath: string, repoRoot: string): string {
 	return absolutePath.split("\\").join("/");
 }
 
+// The plan-level evidence root stays fixed for the whole run, unlike the per-goal attempt dir, so
+// long lanes that span goals have one stable place to write artifacts.
+export function ulwLoopEvidenceRoot(scope?: UlwLoopScope): string {
+	const sessionId = normalizeUlwLoopSessionId(scope?.sessionId);
+	return sessionId === null ? ".omo/evidence" : `.omo/evidence/ulw/${sessionId}`;
+}
+
 // Both the status --json emitter and the checkpoint enforcement resolve the attempt dir through
 // this function from the scope alone; a second resolution path (env, a literal placeholder)
 // would let the gate reject its own advertised directory.

package/packages/omo-codex/plugin/components/ulw-loop/src/plan-crud.ts

@@ -8,6 +8,7 @@ import {
 import { beforePlanMutation, commit } from "./plan-commit.js";
 import { appendGoalToPlan, deriveGoalCandidates, makeGoal } from "./plan-goal-factory.js";
 import { planExists, readUlwLoopPlan, withUlwLoopMutationLock } from "./plan-io.js";
+import type { SuccessCriterionInput } from "./success-criteria-input.js";
 import type { UlwLoopToolkitSurface } from "./surface.js";
 import type {
 	UlwLoopCodexGoalMode,
@@ -20,6 +21,7 @@ import { iso, UlwLoopError } from "./types.js";
 import { parseValidationBatches } from "./validation-batch.js";
 
 export { deriveGoalCandidates, seedDefaultSuccessCriteria } from "./plan-goal-factory.js";
+export type { SuccessCriterionInput } from "./success-criteria-input.js";
 
 export type UlwLoopPlanSummary = {
 	readonly total: number;
@@ -81,7 +83,7 @@ export async function createUlwLoopPlan(
 		}
 		const now = iso();
 		const goals = deriveGoalCandidates(args.brief).map((goal, index) =>
-			makeGoal(goal.title, goal.objective, index, now),
+			makeGoal(goal.title, goal.objective, index, now, { surface }),
 		);
 		const plan: UlwLoopPlan = {
 			version: 1,
@@ -128,13 +130,17 @@ function completedPlanExistsError(scope: UlwLoopScope | undefined, surface: UlwL
 
 export async function addUlwLoopGoal(
 	repoRoot: string,
-	args: { title: string; objective: string },
+	args: { title: string; objective: string; successCriteria?: readonly SuccessCriterionInput[] },
 	scope?: UlwLoopScope,
+	surface: UlwLoopToolkitSurface = "lazycodex",
 ): Promise<{ plan: UlwLoopPlan; goal: UlwLoopItem }> {
 	return withUlwLoopMutationLock(repoRoot, scope, async () => {
 		const plan = await readUlwLoopPlan(repoRoot, scope);
 		const now = iso();
-		const goal = appendGoalToPlan(plan, args.title, args.objective, now);
+		const goal = appendGoalToPlan(plan, args.title, args.objective, now, {
+			surface,
+			...(args.successCriteria === undefined ? {} : { successCriteria: args.successCriteria }),
+		});
 		await commit(repoRoot, scope, {
 			plan,
 			entries: [{ at: now, kind: "goal_added", goalId: goal.id, status: goal.status, message: goal.title }],

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

@@ -1,6 +1,14 @@
+import { criteriaFromInput, criterionId, type SuccessCriterionInput } from "./success-criteria-input.js";
+import type { UlwLoopToolkitSurface } from "./surface.js";
 import type { UlwLoopItem, UlwLoopPlan, UlwLoopSuccessCriterion } from "./types.js";
 import { UlwLoopError } from "./types.js";
 
+export interface GoalSeedOptions {
+	readonly goalId?: string;
+	readonly surface?: UlwLoopToolkitSurface;
+	readonly successCriteria?: readonly SuccessCriterionInput[];
+}
+
 function cleanLine(line: string): string {
 	return line.replace(/^\s*(?:[-*+]\s+|\d+[.)]\s+)/, "").trim();
 }
@@ -38,40 +46,44 @@ function truncateObjective(objective: string): string {
 	return objective.length > 80 ? `${objective.slice(0, 77).trimEnd()}...` : objective;
 }
 
-export function seedDefaultSuccessCriteria(goalIndex: number, objective: string): UlwLoopSuccessCriterion[] {
+// The placeholder must name the exact call that replaces it on the surface the plan is driven from,
+// so a goal seeded without criteria costs one documented call per criterion instead of a doc hunt.
+function replaceVia(goalId: string, id: string, surface: UlwLoopToolkitSurface): string {
+	return surface === "omo-senpi"
+		? `Replace via agentToolkit.steer({ kind: "revise_criterion", source: "finding", goalId: "${goalId}", criterionId: "${id}", scenario, expectedEvidence, evidence, rationale }) (or pass successCriteria to addGoal)`
+		: `Replace via omo-agent-toolkit ulw-loop steer --kind revise_criterion --goal-id ${goalId} --criterion-id ${id} --scenario "<scenario>" --expected-evidence "<proof>" --evidence "<why>" --rationale "<why>"`;
+}
+
+export function seedDefaultSuccessCriteria(
+	goalIndex: number,
+	objective: string,
+	options: Pick<GoalSeedOptions, "goalId" | "surface"> = {},
+): UlwLoopSuccessCriterion[] {
 	const subject = truncateObjective(normalizeObjective(objective) || `Goal ${goalIndex + 1}`);
+	const goalId = options.goalId ?? `G${String(goalIndex + 1).padStart(3, "0")}`;
+	const surface = options.surface ?? "lazycodex";
 	const rows = [
+		["happy", `happy path for: ${subject}`, `observable happy-path proof for goal ${goalIndex + 1}`, true],
+		["edge", "edge case (boundary/empty/malformed)", `boundary or malformed-input proof for: ${subject}`, true],
 		[
-			"C001",
-			"happy",
-			`happy path for: ${subject}`,
-			`Replace via revise_criterion with observable happy-path proof for goal ${goalIndex + 1}.`,
-			true,
-		],
-		[
-			"C002",
-			"edge",
-			"edge case (boundary/empty/malformed)",
-			`Replace via revise_criterion with boundary or malformed-input proof for: ${subject}.`,
-			true,
-		],
-		[
-			"C003",
 			"regression",
 			"regression: adjacent surface still works",
-			`Replace via revise_criterion with regression proof for neighboring behavior after: ${subject}.`,
+			`regression proof for neighboring behavior after: ${subject}`,
 			false,
 		],
 	] as const;
-	return rows.map(([id, userModel, scenario, expectedEvidence, essential]) => ({
-		id,
-		scenario,
-		userModel,
-		expectedEvidence,
-		essential,
-		capturedEvidence: null,
-		status: "pending",
-	}));
+	return rows.map(([userModel, scenario, proof, essential], index) => {
+		const id = criterionId(index);
+		return {
+			id,
+			scenario,
+			userModel,
+			expectedEvidence: `${replaceVia(goalId, id, surface)} with ${proof}.`,
+			essential,
+			capturedEvidence: null,
+			status: "pending",
+		};
+	});
 }
 
 export function deriveGoalCandidates(brief: string): Array<{ title: string; objective: string }> {
@@ -101,23 +113,43 @@ export function deriveGoalCandidates(brief: string): Array<{ title: string; obje
 	}));
 }
 
-export function makeGoal(title: string, objective: string, index: number, now: string): UlwLoopItem {
+export function makeGoal(
+	title: string,
+	objective: string,
+	index: number,
+	now: string,
+	options: GoalSeedOptions = {},
+): UlwLoopItem {
 	const cleanTitle = assertNonEmpty(title, "title");
 	const cleanObjective = assertNonEmpty(objective, "objective");
+	const id = normalizeGoalId(cleanTitle, index);
+	const successCriteria =
+		options.successCriteria === undefined
+			? seedDefaultSuccessCriteria(index, cleanObjective, {
+					goalId: id,
+					...(options.surface === undefined ? {} : { surface: options.surface }),
+				})
+			: criteriaFromInput(options.successCriteria);
 	return {
-		id: normalizeGoalId(cleanTitle, index),
+		id,
 		title: cleanTitle,
 		objective: cleanObjective,
 		status: "pending",
-		successCriteria: seedDefaultSuccessCriteria(index, cleanObjective),
+		successCriteria,
 		attempt: 0,
 		createdAt: now,
 		updatedAt: now,
 	};
 }
 
-export function appendGoalToPlan(plan: UlwLoopPlan, title: string, objective: string, now: string): UlwLoopItem {
-	const goal = makeGoal(title, objective, plan.goals.length, now);
+export function appendGoalToPlan(
+	plan: UlwLoopPlan,
+	title: string,
+	objective: string,
+	now: string,
+	options: GoalSeedOptions = {},
+): UlwLoopItem {
+	const goal = makeGoal(title, objective, plan.goals.length, now, options);
 	plan.goals.push(goal);
 	plan.updatedAt = now;
 	return goal;

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

@@ -6,6 +6,7 @@ import {
 	readCodexGoalSnapshotInput,
 	reconcileCodexGoalSnapshot,
 } from "./codex-goal-snapshot.js";
+import { acknowledgeDriverObjective, acknowledgedDriverObjectives } from "./driver-objective-ack.js";
 import { compatibleCodexObjectives, expectedCodexObjective, isFinalRunCompletionCandidate } from "./goal-status.js";
 import type { UlwLoopScope } from "./paths.js";
 import { commit } from "./plan-commit.js";
@@ -40,12 +41,13 @@ function nextGoalId(plan: UlwLoopPlan): string {
 
 function appendBlockerGoal(plan: UlwLoopPlan, args: RecordFinalReviewBlockersArgs, now: string): UlwLoopItem {
 	const index = plan.goals.length;
+	const id = nextGoalId(plan);
 	const goal: UlwLoopItem = {
-		id: nextGoalId(plan),
+		id,
 		title: args.title,
 		objective: args.objective,
 		status: "pending",
-		successCriteria: seedDefaultSuccessCriteria(index, args.objective),
+		successCriteria: seedDefaultSuccessCriteria(index, args.objective, { goalId: id }),
 		attempt: 0,
 		createdAt: now,
 		updatedAt: now,
@@ -70,8 +72,10 @@ export async function recordFinalReviewBlockers(
 		const reconciliation = reconcileCodexGoalSnapshot(snapshot, {
 			expectedObjective: expectedCodexObjective(plan, goal),
 			acceptedObjectives: compatibleCodexObjectives(plan),
+			acknowledgedObjectives: acknowledgedDriverObjectives(plan),
 		});
 		if (!reconciliation.ok) throw new CodexGoalSnapshotError(formatCodexGoalReconciliation(reconciliation));
+		acknowledgeDriverObjective(plan, reconciliation.unacknowledgedObjective);
 
 		const now = iso();
 		for (const field of BLOCKER_FIELDS) Reflect.deleteProperty(goal, field);
@@ -95,8 +99,8 @@ export async function recordFinalReviewBlockers(
 			blockedGoal: goal,
 			newGoal,
 			ledgerEntries,
-			nextActions: reconciliation.warnings,
-			warnings: reconciliation.warnings.filter((warning) => warning.startsWith("driver_objective_differs")),
+			nextActions: reconciliation.nextActions,
+			warnings: reconciliation.warnings,
 		};
 	});
 }