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

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

@@ -5,6 +5,7 @@ import {
 	normalizeUlwLoopSessionId,
 	type UlwLoopScope,
 	ulwLoopAttemptEvidenceDir,
+	ulwLoopEvidenceRoot,
 	ulwLoopGoalsRelativePath,
 } from "../paths.js";
 import { addUlwLoopGoal, createUlwLoopPlan, startNextUlwLoop, summarizeUlwLoopPlan } from "../plan-crud.js";
@@ -86,9 +87,10 @@ function unreachable(value: never): never {
 	throw new UlwLoopError(`Unhandled operation: ${String(value)}`, "ULW_LOOP_OPERATION_UNHANDLED");
 }
 
-function nextActionsFrom(result: object): readonly string[] {
-	if (!("nextActions" in result) || !Array.isArray(result.nextActions)) return [];
-	return result.nextActions.filter((action): action is string => typeof action === "string").slice(0, 8);
+function stringsFrom(result: object, key: "nextActions" | "warnings"): readonly string[] {
+	if (!(key in result)) return [];
+	const value = Object.entries(result).find(([name]) => name === key)?.[1];
+	return Array.isArray(value) ? value.filter((item): item is string => typeof item === "string").slice(0, 8) : [];
 }
 
 function checkpointWithValidatedSnapshot(
@@ -116,8 +118,15 @@ export function createAgentToolkit(context: ToolkitContext, deps: AgentToolkitDe
 	): Promise<ToolkitResponseFor<Operation>> => {
 		try {
 			const result = await fn();
-			const nextActions = typeof result === "object" && result !== null ? nextActionsFrom(result) : [];
-			return await notify(operation, { ok: true, operation, result, nextActions });
+			const nextActions = typeof result === "object" && result !== null ? stringsFrom(result, "nextActions") : [];
+			const warnings = typeof result === "object" && result !== null ? stringsFrom(result, "warnings") : [];
+			return await notify(operation, {
+				ok: true,
+				operation,
+				result,
+				nextActions,
+				...(warnings.length === 0 ? {} : { warnings }),
+			});
 		} catch (error) {
 			if (error instanceof UlwLoopError && error.code === "ULW_LOOP_PLAN_MISSING" && context.surface === "omo-senpi")
 				return notify(
@@ -177,6 +186,7 @@ export function createAgentToolkit(context: ToolkitContext, deps: AgentToolkitDe
 					plan,
 					summary: summarizeUlwLoopPlan(plan),
 					nextActions: statusNextActions(plan, context.surface),
+					evidenceRoot: ulwLoopEvidenceRoot(scope),
 					// Attempt directories are an evidence-layout v2 concept; a v1 plan must not advertise one.
 					...(active === undefined || plan.evidenceLayoutVersion !== 2
 						? {}
@@ -190,8 +200,8 @@ export function createAgentToolkit(context: ToolkitContext, deps: AgentToolkitDe
 					? checkpointTemplate(context.cwd, scope, args.goalId, { surface: context.surface })
 					: checkpointWithValidatedSnapshot(context, scope, args),
 			),
-		steer: (args) => invoke("steer", () => steerUlwLoop(context.cwd, args, scope)),
-		addGoal: (args) => invoke("add-goal", () => addUlwLoopGoal(context.cwd, args, scope)),
+		steer: (args) => invoke("steer", () => steerUlwLoop(context.cwd, args, scope, context.surface)),
+		addGoal: (args) => invoke("add-goal", () => addUlwLoopGoal(context.cwd, args, scope, context.surface)),
 		criteria: (args) =>
 			invoke("criteria", async () => {
 				const plan = await readUlwLoopPlan(context.cwd, scope);

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

@@ -15,7 +15,12 @@ export type UlwLoopOperation = (typeof ULW_LOOP_OPERATIONS)[number];
 
 export interface ToolkitOperationManifest {
 	readonly name: UlwLoopOperation;
+	/** The camelCase method that runs this operation on every SDK surface. */
+	readonly method: string;
 	readonly mutating: boolean;
+	readonly description: string;
+	/** Argument field -> type notation; a trailing `?` marks an optional field. */
+	readonly args: Readonly<Record<string, string>>;
 }
 
 export interface ToolkitManifest {
@@ -24,19 +29,128 @@ export interface ToolkitManifest {
 	readonly operations: readonly ToolkitOperationManifest[];
 }
 
+const CRITERION_INPUT =
+	'{ scenario: string, expectedEvidence: string, userModel?: "happy" | "edge" | "regression" | "adversarial", essential?: boolean }';
+const STEER_KINDS =
+	'"add_subgoal" | "split_subgoal" | "reorder_pending" | "revise_pending_wording" | "revise_criterion" | "annotate_ledger" | "mark_blocked_superseded"';
+
 export const ULW_LOOP_MANIFEST = {
 	version: 1,
 	name: "ulw-loop",
 	operations: [
-		{ name: "help", mutating: false },
-		{ name: "create-goals", mutating: true },
-		{ name: "status", mutating: false },
-		{ name: "complete-goals", mutating: true },
-		{ name: "checkpoint", mutating: true },
-		{ name: "steer", mutating: true },
-		{ name: "add-goal", mutating: true },
-		{ name: "criteria", mutating: false },
-		{ name: "record-evidence", mutating: true },
-		{ name: "record-review-blockers", mutating: true },
+		{
+			name: "help",
+			method: "help",
+			mutating: false,
+			description: "Return this manifest: every operation with its method name, argument fields, and what it does.",
+			args: {},
+		},
+		{
+			name: "create-goals",
+			method: "createGoals",
+			mutating: true,
+			description:
+				"Create the session plan from a brief; one goal per bullet, each seeded with placeholder criteria until revised.",
+			args: {
+				brief: "string",
+				codexGoalMode: '"aggregate" | "per_story"?',
+				force: "boolean?",
+				validationBatchesJson: "string?",
+			},
+		},
+		{
+			name: "status",
+			method: "status",
+			mutating: false,
+			description:
+				"Read the plan, its summary, structured nextActions, the stable evidenceRoot, and the active goal's currentAttemptDir.",
+			args: {},
+		},
+		{
+			name: "complete-goals",
+			method: "completeGoals",
+			mutating: true,
+			description:
+				"Acquire the next eligible goal or resume the in-progress one; returns { done: true } once the aggregate is complete.",
+			args: { retryFailed: "boolean?" },
+		},
+		{
+			name: "checkpoint",
+			method: "checkpoint",
+			mutating: true,
+			description:
+				"Close the goal as complete, failed, or blocked with evidence; the final goal also needs the quality gate. printTemplate returns that gate's template instead.",
+			args: {
+				goalId: "string",
+				status: '"complete" | "failed" | "blocked"',
+				evidence: "string",
+				codexGoalJson: "string?",
+				qualityGateJson: "string?",
+				printTemplate: "true? (with goalId? only)",
+			},
+		},
+		{
+			name: "steer",
+			method: "steer",
+			mutating: true,
+			description:
+				"Propose an evidence-backed plan mutation; revise_criterion replaces a criterion's scenario, expectedEvidence, or userModel.",
+			args: {
+				kind: STEER_KINDS,
+				source: '"finding" | "user_prompt_submit" | "cli"',
+				evidence: "string",
+				rationale: "string",
+				goalId: "string?",
+				criterionId: "string? (revise_criterion)",
+				scenario: "string? (revise_criterion)",
+				expectedEvidence: "string? (revise_criterion)",
+				userModel: '"happy" | "edge" | "regression" | "adversarial"? (revise_criterion)',
+				title: "string? (add_subgoal)",
+				objective: "string? (add_subgoal)",
+				childGoals: "{ title: string, objective: string }[]? (split_subgoal)",
+				revisedTitle: "string? (revise_pending_wording)",
+				revisedObjective: "string? (revise_pending_wording)",
+				pendingOrder: "string[]? (reorder_pending)",
+				blockedReason: "string? (mark_blocked_superseded)",
+				idempotencyKey: "string?",
+			},
+		},
+		{
+			name: "add-goal",
+			method: "addGoal",
+			mutating: true,
+			description:
+				"Append a goal; pass successCriteria to define its criteria in the same call, otherwise placeholders name the revise call.",
+			args: { title: "string", objective: "string", successCriteria: `${CRITERION_INPUT}[]?` },
+		},
+		{
+			name: "criteria",
+			method: "criteria",
+			mutating: false,
+			description: "List one goal's success criteria with their status and captured evidence.",
+			args: { goalId: "string" },
+		},
+		{
+			name: "record-evidence",
+			method: "recordEvidence",
+			mutating: true,
+			description:
+				"Record a criterion's pass, fail, or blocked evidence; artifacts must exist (resolved against the session cwd) and are stored with the criterion and the ledger entry.",
+			args: {
+				goalId: "string",
+				criterionId: "string",
+				status: '"pass" | "fail" | "blocked"',
+				evidence: "string",
+				notes: "string?",
+				artifacts: "string[]?",
+			},
+		},
+		{
+			name: "record-review-blockers",
+			method: "recordReviewBlockers",
+			mutating: true,
+			description: "Mark the final goal review_blocked and append the blocker goal the reviewer verdict names.",
+			args: { goalId: "string", title: "string", objective: "string", evidence: "string", codexGoalJson: "string?" },
+		},
 	] satisfies readonly ToolkitOperationManifest[],
 } satisfies ToolkitManifest;

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

@@ -63,12 +63,15 @@ export interface ToolkitFailure<Operation extends string = string> {
 	readonly ok: false;
 	readonly operation: Operation;
 	readonly error: ToolkitError;
+	readonly warnings?: readonly string[];
 }
 
 type StatusResult = {
 	readonly plan: UlwLoopPlan;
 	readonly summary: ReturnType<typeof summarizeUlwLoopPlan>;
 	readonly nextActions: readonly string[];
+	/** Plan-level evidence directory, stable for the whole run (relative to the session cwd). */
+	readonly evidenceRoot: string;
 	readonly currentAttemptDir?: string;
 };
 

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

@@ -1,5 +1,6 @@
 // biome-ignore-all format: compact extracted steering mutations stay below the pure LOC budget.
 import { seedDefaultSuccessCriteria } from "./plan-crud.js";
+import type { UlwLoopToolkitSurface } from "./surface.js";
 import type { UlwLoopItem, UlwLoopPlan, UlwLoopSteeringChildGoal, UlwLoopSteeringProposal, UlwLoopSuccessCriterionUserModel } from "./types.js";
 import { ULW_LOOP_SUCCESS_CRITERION_USER_MODELS } from "./types.js";
 import { updateBatchesAfterSupersede } from "./validation-batch.js";
@@ -30,9 +31,9 @@ function nextId(plan: UlwLoopPlan, offset: number): string {
 	return `G${String(max + offset).padStart(3, "0")}`;
 }
 
-export function makeGoal(plan: UlwLoopPlan, childGoal: UlwLoopSteeringChildGoal, evidence: string, now: string, offset: number): UlwLoopItem {
+export function makeGoal(plan: UlwLoopPlan, childGoal: UlwLoopSteeringChildGoal, evidence: string, now: string, offset: number, surface: UlwLoopToolkitSurface = "lazycodex"): UlwLoopItem {
 	const id = nextId(plan, offset); const digits = /^G(\d+)/u.exec(id)?.[1]; const goalIndex = digits === undefined ? plan.goals.length + offset - 1 : Number(digits) - 1;
-	return { id, title: childGoal.title, objective: childGoal.objective, status: "pending", successCriteria: seedDefaultSuccessCriteria(goalIndex, childGoal.objective), attempt: 0, createdAt: now, updatedAt: now, evidence };
+	return { id, title: childGoal.title, objective: childGoal.objective, status: "pending", successCriteria: seedDefaultSuccessCriteria(goalIndex, childGoal.objective, { goalId: id, surface }), attempt: 0, createdAt: now, updatedAt: now, evidence };
 }
 
 export function reviseWording(plan: UlwLoopPlan, proposal: UlwLoopSteeringProposal, now: string): void {
@@ -41,9 +42,9 @@ export function reviseWording(plan: UlwLoopPlan, proposal: UlwLoopSteeringPropos
 	target.steeringEvidence = proposal.evidence; target.steeringRationale = proposal.rationale; target.updatedAt = now;
 }
 
-export function splitOrBlock(plan: UlwLoopPlan, proposal: UlwLoopSteeringProposal, now: string): void {
+export function splitOrBlock(plan: UlwLoopPlan, proposal: UlwLoopSteeringProposal, now: string, surface: UlwLoopToolkitSurface = "lazycodex"): void {
 	const target = goal(plan, targets(proposal)[0]); if (target === undefined) return;
-	const replacements = children(proposal).map((item, index) => makeGoal(plan, item, proposal.evidence, now, index + 1));
+	const replacements = children(proposal).map((item, index) => makeGoal(plan, item, proposal.evidence, now, index + 1, surface));
 	target.steeringEvidence = proposal.evidence; target.steeringRationale = proposal.rationale; target.updatedAt = now;
 	if (replacements.length === 0) { target.status = "blocked"; target.steeringStatus = "blocked"; target.blockedReason = proposal.blockedReason ?? proposal.rationale; }
 	else { target.steeringStatus = "superseded"; target.supersededBy = replacements.map((item) => item.id); for (const item of replacements) item.supersedes = [target.id]; plan.goals.splice(plan.goals.indexOf(target) + 1, 0, ...replacements); updateBatchesAfterSupersede(plan, target.id, replacements.map((item) => item.id)); }

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

@@ -1,4 +1,8 @@
-import type { UlwLoopSteeringMutationKind, UlwLoopSteeringSource } from "./constants.js";
+import type {
+	UlwLoopSteeringMutationKind,
+	UlwLoopSteeringSource,
+	UlwLoopSuccessCriterionUserModel,
+} from "./constants.js";
 import type { UlwLoopItem, UlwLoopPlan } from "./domain-types.js";
 
 export interface UlwLoopSteeringInvariantResult {
@@ -25,9 +29,17 @@ export interface UlwLoopSteeringAfterPayload {
 export interface UlwLoopSteeringProposal {
 	kind: UlwLoopSteeringMutationKind;
 	source: UlwLoopSteeringSource;
+	/** Alias of `targetGoalId`; the SDK documentation uses `goalId` like every other operation. */
+	goalId?: string;
 	targetGoalId?: string;
 	targetGoalIds?: string[];
 	criterionId?: string;
+	/** `revise_criterion` payload: the replacement scenario text. */
+	scenario?: string;
+	/** `revise_criterion` payload: the replacement observable-proof text. */
+	expectedEvidence?: string;
+	/** `revise_criterion` payload: the replacement user model. */
+	userModel?: UlwLoopSuccessCriterionUserModel;
 	evidence: string;
 	rationale: string;
 	title?: string;

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

@@ -5,6 +5,7 @@ import { commit } from "./plan-commit.js";
 import { findAcceptedSteeringLedgerEntry, readUlwLoopPlan, withUlwLoopMutationLock } from "./plan-io.js";
 import { makeGoal, reviseCriterion, reviseWording, splitOrBlock } from "./steering-mutations.js";
 import { buildSteeringPlanSnapshot, changedGoalIdsBetween } from "./steering-snapshot.js";
+import type { UlwLoopToolkitSurface } from "./surface.js";
 import type {
 	SteerUlwLoopResult,
 	UlwLoopItem,
@@ -21,7 +22,7 @@ import { iso, ULW_LOOP_STEERING_MUTATION_KINDS, ULW_LOOP_SUCCESS_CRITERION_USER_
 import { batchUpdateLedgerEntry } from "./validation-batch.js";
 
 const SOURCES = ["user_prompt_submit", "finding", "cli"] as const satisfies readonly UlwLoopSteeringSource[];
-const PROTECTED = new Set(["aggregateCompletion", "codexObjective", "codexObjectiveAliases", "originalConstraints", "qualityGate", "status", "completedAt", "completionStatus"]);
+const PROTECTED = new Set(["aggregateCompletion", "codexObjective", "codexObjectiveAliases", "acknowledgedDriverObjectives", "originalConstraints", "qualityGate", "status", "completedAt", "completionStatus"]);
 const isObject = (value: unknown): value is object => typeof value === "object" && value !== null; const isPlain = (value: unknown): value is object => isObject(value) && !Array.isArray(value);
 const read = (value: object, key: string): unknown => Object.entries(value).find(([name]) => name === key)?.[1];
 const isText = (value: unknown): value is string => typeof value === "string" && value.trim().length > 0;
@@ -156,17 +157,17 @@ function validateCriterion(plan: UlwLoopPlan, proposal: object, reasons: string[
 	if (model !== undefined && !isModel(model)) reasons.push("invalid userModel");
 }
 
-export function applySteeringMutation(plan: UlwLoopPlan, proposal: UlwLoopSteeringProposal, audit: UlwLoopSteeringAudit): UlwLoopPlan {
+export function applySteeringMutation(plan: UlwLoopPlan, proposal: UlwLoopSteeringProposal, audit: UlwLoopSteeringAudit, surface: UlwLoopToolkitSurface = "lazycodex"): UlwLoopPlan {
 	const next = structuredClone(plan);
 	if (!audit.invariant.accepted) return next;
 	const now = proposal.now?.toISOString() ?? iso();
-	if (proposal.kind === "add_subgoal") next.goals.push(makeGoal(next, { title: proposal.title ?? "", objective: proposal.objective ?? "" }, proposal.evidence, now, 1));
+	if (proposal.kind === "add_subgoal") next.goals.push(makeGoal(next, { title: proposal.title ?? "", objective: proposal.objective ?? "" }, proposal.evidence, now, 1, surface));
 	if (proposal.kind === "reorder_pending") {
 		const order = pendingOrder(proposal);
 		next.goals = [...order.map((id) => goal(next, id)).filter((item): item is UlwLoopItem => item !== undefined), ...next.goals.filter((item) => !order.includes(item.id))];
 	}
 	if (proposal.kind === "revise_pending_wording") reviseWording(next, proposal, now);
-	if (proposal.kind === "split_subgoal" || proposal.kind === "mark_blocked_superseded") splitOrBlock(next, proposal, now);
+	if (proposal.kind === "split_subgoal" || proposal.kind === "mark_blocked_superseded") splitOrBlock(next, proposal, now, surface);
 	if (proposal.kind === "revise_criterion") reviseCriterion(next, proposal, now);
 	if (proposal.kind !== "annotate_ledger") next.updatedAt = now;
 	return next;
@@ -188,7 +189,7 @@ export function parseUlwLoopSteeringDirective(text: string): UlwLoopSteeringProp
 	}
 }
 
-export async function steerUlwLoop(repoRoot: string, proposal: UlwLoopSteeringProposal, scope?: UlwLoopScope): Promise<SteerUlwLoopResult> {
+export async function steerUlwLoop(repoRoot: string, proposal: UlwLoopSteeringProposal, scope?: UlwLoopScope, surface: UlwLoopToolkitSurface = "lazycodex"): Promise<SteerUlwLoopResult> {
 	return withUlwLoopMutationLock(repoRoot, scope, async () => {
 		const plan = await readUlwLoopPlan(repoRoot, scope);
 		const key = proposal.idempotencyKey ?? proposal.promptSignature;
@@ -201,7 +202,7 @@ export async function steerUlwLoop(repoRoot: string, proposal: UlwLoopSteeringPr
 		}
 		const audit = validateUlwLoopSteeringProposal(plan, proposal);
 		const accepted = audit.invariant.accepted;
-		const next = accepted ? applySteeringMutation(plan, proposal, audit) : plan;
+		const next = accepted ? applySteeringMutation(plan, proposal, audit, surface) : plan;
 		const finalAudit: UlwLoopSteeringAudit = { ...audit };
 		if (accepted) {
 			const changed = changedGoalIdsBetween(plan, next);

package/packages/omo-codex/plugin/components/ulw-loop/src/success-criteria-input.ts

@@ -0,0 +1,56 @@
+import type { UlwLoopSuccessCriterion, UlwLoopSuccessCriterionUserModel } from "./types.js";
+import { ULW_LOOP_SUCCESS_CRITERION_USER_MODELS, UlwLoopError } from "./types.js";
+
+export interface SuccessCriterionInput {
+	readonly scenario: string;
+	readonly expectedEvidence: string;
+	readonly userModel?: UlwLoopSuccessCriterionUserModel;
+	readonly essential?: boolean;
+}
+
+function invalid(message: string, details: Record<string, unknown>): never {
+	throw new UlwLoopError(`Invalid successCriteria: ${message}`, "ULW_LOOP_ARGUMENT_INVALID", { details });
+}
+
+function isUserModel(value: unknown): value is UlwLoopSuccessCriterionUserModel {
+	return typeof value === "string" && ULW_LOOP_SUCCESS_CRITERION_USER_MODELS.some((model) => model === value);
+}
+
+function requireText(value: unknown, field: string, index: number): string {
+	const trimmed = typeof value === "string" ? value.trim() : "";
+	return trimmed || invalid(`entry ${index + 1} needs a non-empty ${field}.`, { index, field });
+}
+
+export function criterionId(index: number): string {
+	return `C${String(index + 1).padStart(3, "0")}`;
+}
+
+export function criteriaFromInput(input: readonly unknown[]): UlwLoopSuccessCriterion[] {
+	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: Record<string, unknown> = { ...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/test/codex-goal-snapshot.test.ts

@@ -152,6 +152,41 @@ describe("reconcileCodexGoalSnapshot", () => {
 		expect(reconciliation.ok).toBe(true);
 		expect(reconciliation.errors).toHaveLength(0);
 		expect(reconciliation.warnings.join(" ")).toContain("driver_objective_differs");
+		expect(reconciliation.nextActions).toEqual([]);
+		expect(reconciliation.unacknowledgedObjective).toBe("X");
+	});
+
+	it("#given the differing objective was acknowledged #when reconciled again #then it is silent", () => {
+		const reconciliation = reconcileCodexGoalSnapshot(
+			{ available: true, objective: " X  \n", status: "active", raw: null },
+			{ expectedObjective: "Y", acknowledgedObjectives: ["X"] },
+		);
+
+		expect(reconciliation.warnings).toEqual([]);
+		expect(reconciliation.nextActions).toEqual([]);
+		expect(reconciliation.unacknowledgedObjective).toBeUndefined();
+	});
+
+	it("#given no driver snapshot #when reconciled #then create_goal is a next action, not a warning", () => {
+		const reconciliation = reconcileCodexGoalSnapshot(null, { expectedObjective: "Y" });
+
+		expect(reconciliation.nextActions.join(" ")).toContain("create_goal");
+		expect(reconciliation.warnings).toEqual([]);
+	});
+
+	it("#given a completed or limited driver #when reconciled #then the advice is a next action", () => {
+		const completed = reconcileCodexGoalSnapshot(
+			{ available: true, objective: "Y", status: "complete", raw: null },
+			{ expectedObjective: "Y" },
+		);
+		const limited = reconcileCodexGoalSnapshot(
+			{ available: true, objective: "Y", status: "usage_limited", raw: null },
+			{ expectedObjective: "Y" },
+		);
+
+		expect(completed.nextActions.join(" ")).toContain("create_goal");
+		expect(limited.nextActions.join(" ")).toContain("/goal resume");
+		expect([...completed.warnings, ...limited.warnings]).toEqual([]);
 	});
 
 	it("accepts a parsable snapshot without objective as advisory", () => {
@@ -176,7 +211,8 @@ describe("reconcileCodexGoalSnapshot", () => {
 		// then
 		expect(reconciliation.ok).toBe(true);
 		expect(reconciliation.errors).toHaveLength(0);
-		expect(reconciliation.warnings.join(" ")).toContain("/goal resume");
+		expect(reconciliation.nextActions.join(" ")).toContain("/goal resume");
+		expect(reconciliation.warnings).toEqual([]);
 	});
 });
 

package/packages/omo-codex/plugin/components/ulw-loop/test/sdk-driver-states.test.ts

@@ -21,12 +21,17 @@ interface Seeded {
 
 // One fixture shape for every driver state: a real plan whose first goal is ready to close, so the
 // only thing under test is what the driver snapshot does to the checkpoint.
-async function seed(sessionId: string): Promise<Seeded> {
+async function seed(sessionId: string, brief = "- alpha goal\n- beta goal"): Promise<Seeded> {
 	const cwd = await mkdtemp(join(tmpdir(), "ulw-driver-"));
 	workDirs.push(cwd);
 	const toolkit = createAgentToolkit({ cwd, sessionId, surface: "omo-senpi" });
-	const created = await toolkit.createGoals({ brief: "- alpha goal\n- beta goal" });
+	const created = await toolkit.createGoals({ brief });
 	if (!created.ok) throw new Error("fixture could not create goals");
+	return passNextGoal(cwd, sessionId);
+}
+
+async function passNextGoal(cwd: string, sessionId: string): Promise<Seeded> {
+	const toolkit = createAgentToolkit({ cwd, sessionId, surface: "omo-senpi" });
 	const started = await toolkit.completeGoals({});
 	if (!started.ok || started.operation !== "complete-goals" || "done" in started.result)
 		throw new Error("fixture could not start a goal");
@@ -46,6 +51,10 @@ async function seed(sessionId: string): Promise<Seeded> {
 	return { cwd, sessionId, goalId, objective: plan.codexObjective ?? "" };
 }
 
+function warningsOf(result: object): readonly string[] {
+	return "warnings" in result && Array.isArray(result.warnings) ? result.warnings : [];
+}
+
 async function closeWith(seeded: Seeded, snapshot?: Record<string, unknown>) {
 	const toolkit = createAgentToolkit({ cwd: seeded.cwd, sessionId: seeded.sessionId, surface: "omo-senpi" });
 	return toolkit.checkpoint({
@@ -108,15 +117,35 @@ describe("SDK driver-goal states", () => {
 	});
 
 	describe("#given a driver whose objective differs from the plan", () => {
-		it("#when the goal is checkpointed #then the difference is reported, never a rejection", async () => {
+		it("#when the goal is checkpointed #then the difference is a warning, never a rejection and never a next action", async () => {
 			const seeded = await seed("driver-differs");
 
 			const closed = await closeWith(seeded, { goal: { objective: "a different objective", status: "active" } });
 
 			expect(closed.ok).toBe(true);
 			if (closed.ok) {
-				expect([...(closed.warnings ?? []), ...closed.nextActions].join(" ")).toContain("driver_objective_differs");
+				expect(warningsOf(closed.result).join(" ")).toContain("driver_objective_differs");
+				expect(closed.nextActions.join(" ")).not.toContain("driver_objective_differs");
+				expect(closed.nextActions.join(" ")).not.toContain("create_goal");
+			}
+		});
+
+		it("#when a later goal is checkpointed under the same driver #then the difference is acknowledged in the plan and not repeated", async () => {
+			const first = await seed("driver-differs-once", "- alpha goal\n- beta goal\n- gamma goal");
+			const driver = { goal: { objective: "  a different\n objective  ", status: "active" } };
+
+			const firstClose = await closeWith(first, driver);
+			const second = await passNextGoal(first.cwd, first.sessionId);
+			const secondClose = await closeWith(second, driver);
+
+			expect(firstClose.ok && secondClose.ok).toBe(true);
+			if (firstClose.ok && secondClose.ok) {
+				expect(warningsOf(firstClose.result).join(" ")).toContain("driver_objective_differs");
+				expect(warningsOf(secondClose.result)).toEqual([]);
+				expect(secondClose.nextActions).toEqual([]);
 			}
+			const plan = await readUlwLoopPlan(first.cwd, { sessionId: first.sessionId });
+			expect(plan.acknowledgedDriverObjectives).toEqual(["a different objective"]);
 		});
 	});