oh-my-opencode 4.19.0 → 4.19.2

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

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-ulw-loop",
-	"version": "4.19.0",
+	"version": "4.19.2",
 	"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/skills/ulw-loop/SKILL.md

@@ -20,6 +20,7 @@ This skill is intentionally compact. The full workflow lives in `references/full
 ## Non-Negotiables
 
 - Use the ulw-loop CLI state under `.omo/ulw-loop`; do not hand-edit goal state.
+- Register goals up front (`omo ulw-loop create-goals`, then `create_goal` from the printed handoff) and mirror every atomic step into the live `update_plan` checklist: one ultra-granular step per action, exactly one in_progress, transitions marked the instant they happen.
 - After any compaction or context loss, re-read brief + goals + ledger FIRST plus `omo ulw-loop status --json`, then resume; never re-plan from scratch.
 - If `omo ulw-loop create-goals` says the existing aggregate is already complete, start unrelated new work with a fresh `--session-id <new-id>` instead of steering or forcing the completed default state. Use `--force` only to intentionally overwrite completed evidence.
 - Every success criterion needs observable evidence from a real surface: a channel (terminal/TUI via the xterm.js web terminal, HTTP, browser, computer-use) or, for CLI- or data-shaped criteria, an auxiliary surface (CLI stdout, DB diff, parsed config dump).
@@ -31,7 +32,7 @@ This skill is intentionally compact. The full workflow lives in `references/full
 - Track spawned agent names locally. Use `wait_agent` for mailbox signals, not proof of completion. A timeout only means no new mailbox update arrived. Treat a running child as alive.
 - While children run, surface the active subagent count, agent names, and latest `WORKING:` phase.
 - Fallback only when the child is completed without the deliverable, ack-only after `followup_task`, explicitly `BLOCKED:`, or no longer running. Then record inconclusive and respawn a smaller `fork_turns: "none"` task with the missing deliverable.
-- Use `git-master` for git-tracked edits: inspect recent and touched-path commit history, then commit each verified work unit atomically in the repository's observed language, scope, and message style with only that unit's files staged.
+- Use `git-master` for git-tracked edits: inspect recent and touched-path commit history, then commit each verified work unit atomically in the repository's observed language, scope, and message style with only that unit's files staged. Never carry verified units into a later omnibus commit.
 
 ## Codex Tool Mapping
 

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

@@ -113,9 +113,9 @@ If `ULW_LOOP_CLI` is empty, open the durable notepad first, record the missing C
 
 Run one form:
 ```sh
-omo ulw-loop create-goals --brief "<brief>" --json
-omo ulw-loop create-goals --brief-file <path> --json
-cat <brief> | omo ulw-loop create-goals --from-stdin --json
+omo ulw-loop create-goals --brief "<brief>" [--validation-batch-json <json-or-path>] --json
+omo ulw-loop create-goals --brief-file <path> [--validation-batch-json <json-or-path>] --json
+cat <brief> | omo ulw-loop create-goals --from-stdin [--validation-batch-json <json-or-path>] --json
 ```
 If the existing aggregate is already complete, do not steer or force the
 completed default state for unrelated new work. Start a fresh run with
@@ -145,7 +145,7 @@ Read pending goals, criteria IDs, current ledger head, blockers, and aggregate C
 Loop per goal. Cap at 5 cycles per goal. Cap identical same-criterion failures at 3.
 
 ### Acquire Next Goal
-1. Run `omo ulw-loop complete-goals --json` and read the handoff, including criteria.
+1. Run `omo ulw-loop complete-goals --json` and read the handoff, including criteria. After the first goal starts, a successful complete checkpoint normally prints the next goal instruction directly; use `complete-goals` as the manual fallback/resume path.
 2. Call `get_goal` and inspect active Codex state.
 3. Apply this table exactly:
 
@@ -177,7 +177,7 @@ Loop per goal. Cap at 5 cycles per goal. Cap identical same-criterion failures a
 ### Goal Completion
 1. Non-final aggregate goal: confirm every `essential` criterion is `pass`; non-essential criteria may remain pending. Final aggregate goal: confirm every criterion across the whole plan is `pass`.
 2. Call `get_goal` for a fresh snapshot.
-3. Run `omo ulw-loop checkpoint --goal-id <id> --status complete --evidence "<criteria evidence summary>" --codex-goal-json <snapshot> --json`.
+3. Run `omo ulw-loop checkpoint --goal-id <id> --status complete --evidence "<criteria evidence summary>" --codex-goal-json <snapshot> --json`; on success it auto-starts and prints the next eligible goal unless `--no-advance` is passed.
 4. If blocked or failed, checkpoint with `--status blocked` or `--status failed` and include diagnosis evidence.
 5. If this is the final goal, run the final quality gate first and pass `--quality-gate-json`.
 
@@ -219,7 +219,9 @@ Use steering only for structured evidence-backed mutation. Reject natural-langua
 | annotate_ledger | Audit-only note | `--evidence`, `--rationale` |
 | mark_blocked_superseded | Old story replaced by new evidence | `--goal-id`, `--replacements?`, `--evidence`, `--rationale` |
 
-Command form: `omo ulw-loop steer --kind <kind> [<kind-specific-fields>] --evidence "<...>" --rationale "<...>" --json`.
+Command form: `omo ulw-loop steer --kind <kind> [<kind-specific-fields>] --evidence "<...>" --rationale "<...>" --json`. For multiple evidence-backed plan-shape changes discovered together, pass `--proposals-json <json-or-path>` with an array of proposals; the batch applies atomically or rejects without partial plan mutation.
+
+Validation batches are optional aggregate-mode review boundaries declared at create time with `--validation-batch-json`. A batch-final member requires all other members resolved, all member criteria pass, and a member-spanning quality gate; split/supersede steering keeps batch membership updated.
 Structured prompt directives accepted: `OMO_ULW_LOOP_STEER: { ... }`, `omo.ulw-loop.steer: {...}`, `omo ulw-loop steer: {...}`.
 
 ## Constraints

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

@@ -0,0 +1,84 @@
+import { type CheckpointUlwLoopArgs, type CheckpointUlwLoopResult, checkpointUlwLoop } from "./checkpoint.js";
+import { hasFlag, parseCodexGoalJson, readValue } from "./cli-arg-parser.js";
+import { blockedDecisionHandoff, printJson } from "./cli-output.js";
+import { buildCodexGoalInstruction, type UlwLoopGoalInstruction } from "./codex-goal-instruction.js";
+import type { UlwLoopScope } from "./paths.js";
+import { startNextUlwLoop, summarizeUlwLoopPlan } from "./plan-crud.js";
+import type { UlwLoopItem, UlwLoopPlan } from "./types.js";
+import { UlwLoopError } from "./types.js";
+
+type ContinuationNext =
+	| { readonly resumed: boolean; readonly goal: UlwLoopItem; readonly instruction: UlwLoopGoalInstruction }
+	| { readonly done: true; readonly blocked: boolean; readonly handoff: string };
+
+export type CheckpointAndContinueResult = CheckpointUlwLoopResult & { readonly next?: ContinuationNext };
+
+export async function checkpointAndContinue(
+	repoRoot: string,
+	args: CheckpointUlwLoopArgs & { readonly advance: boolean },
+	scope?: UlwLoopScope,
+): Promise<CheckpointAndContinueResult> {
+	const result = await checkpointUlwLoop(repoRoot, args, scope);
+	if (args.status !== "complete" || result.aggregateCompletion !== undefined || !args.advance) return result;
+	const next = await startNextUlwLoop(repoRoot, {}, scope);
+	if ("done" in next) return { ...result, plan: next.plan, next: doneNext(next.plan) };
+	const instruction = buildCodexGoalInstruction({ plan: next.plan, goal: next.goal });
+	return { ...result, plan: next.plan, next: { resumed: next.resumed, goal: next.goal, instruction } };
+}
+
+export async function checkpoint(
+	repoRoot: string,
+	argv: readonly string[],
+	json: boolean,
+	scope?: UlwLoopScope,
+): Promise<number> {
+	const goalId = required(argv, "--goal-id");
+	const statusValue = checkpointStatus(required(argv, "--status"));
+	const evidence = required(argv, "--evidence");
+	const codexGoalJson = await parseCodexGoalJson(
+		statusValue === "complete" ? required(argv, "--codex-goal-json") : readValue(argv, "--codex-goal-json"),
+	);
+	if (statusValue === "complete" && codexGoalJson === undefined) {
+		throw new UlwLoopError("Missing --codex-goal-json.", "ULW_LOOP_CODEX_GOAL_JSON_REQUIRED");
+	}
+	const qualityGateJson = readValue(argv, "--quality-gate-json");
+	const args: CheckpointUlwLoopArgs & { readonly advance: boolean } = {
+		goalId,
+		status: statusValue,
+		evidence,
+		advance: !hasFlag(argv, "--no-advance"),
+		...(codexGoalJson === undefined ? {} : { codexGoalJson }),
+		...(qualityGateJson === undefined ? {} : { qualityGateJson }),
+	};
+	const result = await checkpointAndContinue(repoRoot, args, scope);
+	if (json) printJson({ ok: true, ...result, summary: summarizeUlwLoopPlan(result.plan) });
+	else printCheckpointText(result);
+	return 0;
+}
+
+function printCheckpointText(result: CheckpointAndContinueResult): void {
+	process.stdout.write(`ulw-loop checkpoint: ${result.goal.id} -> ${result.goal.status}\n`);
+	if (result.next === undefined) return;
+	if ("instruction" in result.next) process.stdout.write(`${result.next.instruction.text}\n`);
+	else process.stdout.write(`${result.next.handoff || "ulw-loop: all goals complete"}\n`);
+}
+
+function doneNext(plan: UlwLoopPlan): ContinuationNext {
+	const handoff = blockedDecisionHandoff(plan);
+	return { done: true, blocked: handoff.length > 0, handoff };
+}
+
+function required(argv: readonly string[], flag: string): string {
+	const value = readValue(argv, flag)?.trim();
+	if (value) return value;
+	throw new UlwLoopError(`Missing ${flag}.`, "ULW_LOOP_ARGUMENT_MISSING", { details: { flag } });
+}
+
+function checkpointStatus(value: string): CheckpointUlwLoopArgs["status"] {
+	if (value === "complete" || value === "failed" || value === "blocked") return value;
+	throw new UlwLoopError(
+		"Missing or invalid --status; expected complete, failed, or blocked.",
+		"ULW_LOOP_STATUS_INVALID",
+		{ details: { status: value } },
+	);
+}

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

@@ -1,4 +1,4 @@
-import { ulwLoopAttemptEvidenceDir } from "./paths.js";
+// biome-ignore-all format: checkpoint stays under the pure LOC ceiling.
 import { existsSync, statSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
@@ -20,6 +20,7 @@ import {
 	isFinalRunCompletionCandidate,
 } from "./goal-status.js";
 import type { UlwLoopScope } from "./paths.js";
+import { ulwLoopAttemptEvidenceDir } from "./paths.js";
 import { appendLedger, readUlwLoopPlan, withUlwLoopMutationLock, writePlan } from "./plan-io.js";
 import {
 	classifyExternalAuthorizationBlocker,
@@ -35,6 +36,7 @@ import type {
 	UlwLoopQualityGate,
 } from "./types.js";
 import { iso, UlwLoopError } from "./types.js";
+import { batchClosedBy, requireAllValidationBatchesClosed, requireBatchFinalReady, requireBatchGate } from "./validation-batch.js";
 
 export interface CheckpointUlwLoopArgs {
 	readonly goalId: string;
@@ -169,9 +171,11 @@ export async function checkpointUlwLoop(
 		if (args.status === "complete") {
 			const aggregate = codexGoalMode(plan) === "aggregate";
 			const final = isFinalRunCompletionCandidate(plan, goal);
+			const closesBatch = batchClosedBy(plan, goal.id) !== undefined;
 			if (final) {
 				requireAllCriteriaPass(goal);
 				requireAllPlanCriteriaPass(plan);
+				requireAllValidationBatchesClosed(plan, goal.id);
 			} else if (aggregate) requireEssentialCriteriaPass(goal);
 			else requireAllCriteriaPass(goal);
 			const snapshot = await readCodexGoalSnapshotInput(args.codexGoalJson, repoRoot);
@@ -218,8 +222,11 @@ export async function checkpointUlwLoop(
 						"ulw_loop_codex_snapshot_mismatch",
 					);
 			}
+			if (closesBatch) requireBatchFinalReady(plan, goal);
+			if (closesBatch && args.qualityGateJson === undefined)
+				throw new UlwLoopError("Validation batch final checkpoint requires --quality-gate-json.", "ULW_LOOP_VALIDATION_BATCH_GATE_REQUIRED");
 			if (final) aggregateCompletion = makeAggregateCompletion(now, evidence, codexGoal);
-			if (final || aggregateCompletion !== undefined)
+			if (final || aggregateCompletion !== undefined || closesBatch) {
 				qualityGate = validateQualityGate(await readJsonInput(args.qualityGateJson, repoRoot), {
 					repoRoot,
 					fs: QUALITY_GATE_FS,
@@ -227,6 +234,8 @@ export async function checkpointUlwLoop(
 						? { currentAttemptDir: ulwLoopAttemptEvidenceDir(goal.id, goal.attempt, scope) }
 						: {}),
 				});
+				requireBatchGate(plan, goal, qualityGate);
+			}
 			goal.status = "complete";
 			goal.completedAt = now;
 			goal.evidence = evidence;
@@ -241,6 +250,8 @@ export async function checkpointUlwLoop(
 		await writePlan(repoRoot, plan, scope);
 		const ledgerEntry = buildLedger(now, args, goal, qualityGate, codexGoal, aggregateCompletion);
 		await appendLedger(repoRoot, ledgerEntry, scope);
+		const closedBatch = args.status === "complete" ? batchClosedBy(plan, goal.id) : undefined;
+		if (closedBatch !== undefined) await appendLedger(repoRoot, { at: now, kind: "batch_closed", goalId: goal.id, message: closedBatch.batchId }, scope);
 		return aggregateCompletion === undefined
 			? { plan, goal, ledgerEntry }
 			: { plan, goal, ledgerEntry, aggregateCompletion };

package/packages/omo-codex/plugin/components/ulw-loop/src/cli-arg-parser.ts

@@ -5,7 +5,7 @@ import { UlwLoopError } from "./types.js";
 
 type RecordEvidenceCliArgs = { readonly goalId: string; readonly criterionId: string; readonly status: "pass" | "fail" | "blocked"; readonly evidence: string; readonly notes?: string };
 
-const VALUE_FLAGS = new Set("--brief --brief-file --session-id --codex-goal-mode --goal --goal-id --criterion-id --status --evidence --notes --codex-goal-json --quality-gate-json --kind --rationale --title --objective --target-goal-id --source --after-json --directive-json --directive-file --idempotency-key".split(" "));
+const VALUE_FLAGS = new Set("--brief --brief-file --session-id --codex-goal-mode --validation-batch-json --goal --goal-id --criterion-id --status --evidence --notes --codex-goal-json --quality-gate-json --kind --rationale --title --objective --target-goal-id --source --after-json --directive-json --directive-file --idempotency-key --proposals-json".split(" "));
 const SUBCOMMANDS = new Set("create-goals status complete-goals criteria record-evidence checkpoint steer add-goal record-review-blockers".split(" "));
 
 export function hasFlag(argv: readonly string[], flag: string): boolean { return argv.includes(flag); }

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

@@ -1,9 +1,9 @@
+import { checkpoint } from "./checkpoint-continuation.js";
 import { hasFlag, readValue } from "./cli-arg-parser.js";
 import { printJsonError, ULW_LOOP_HELP } from "./cli-output.js";
 import {
 	addGoal,
 	captureEvidence,
-	checkpoint,
 	completeGoals,
 	createGoals,
 	criteria,

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

@@ -2,13 +2,13 @@ import type { UlwLoopCodexGoalMode, UlwLoopItem, UlwLoopPlan } from "./types.js"
 import { UlwLoopError } from "./types.js";
 
 export const ULW_LOOP_HELP = `Usage:
-  omo ulw-loop create-goals --brief "..." [--brief-file <path>] [--from-stdin] [--codex-goal-mode aggregate|per_story] [--force] [--json]
+  omo ulw-loop create-goals --brief "..." [--brief-file <path>] [--from-stdin] [--codex-goal-mode aggregate|per_story] [--validation-batch-json <json-or-path>] [--force] [--json]
   omo ulw-loop status [--json]
   omo ulw-loop complete-goals [--retry-failed] [--json]
   omo ulw-loop criteria --goal-id <id> [--json]
   omo ulw-loop record-evidence --goal-id <id> --criterion-id <id> --status pass|fail|blocked --evidence "..." [--notes "..."] [--json]
-  omo ulw-loop checkpoint --goal-id <id> --status complete|failed|blocked --evidence "..." --codex-goal-json <...> [--quality-gate-json <...>] [--json]
-  omo ulw-loop steer --kind <kind> ... --evidence "..." --rationale "..." [--json]
+  omo ulw-loop checkpoint --goal-id <id> --status complete|failed|blocked --evidence "..." --codex-goal-json <...> [--quality-gate-json <...>] [--no-advance] [--json]
+  omo ulw-loop steer --kind <kind> ... --evidence "..." --rationale "..." [--proposals-json <json-or-path>] [--json]
   omo ulw-loop add-goal --title "..." --objective "..." [--json]
   omo ulw-loop record-review-blockers --goal-id <id> --title "..." --objective "..." --evidence "..." --codex-goal-json <...> [--json]
 

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

@@ -1,6 +1,7 @@
 // biome-ignore-all format: keep this module under the mandated pure LOC budget.
 import { parseGoalArg, readJsonInput, readValue } from "./cli-arg-parser.js";
 import { printJson, printStatus } from "./cli-output.js";
+import type { SteerUlwLoopBatchResult } from "./steering-batch.js";
 import type { SteerUlwLoopResult, UlwLoopSteeringChildGoal, UlwLoopSteeringMutationKind, UlwLoopSteeringProposal, UlwLoopSteeringSource, UlwLoopSuccessCriterionUserModel } from "./types.js";
 import { ULW_LOOP_STEERING_MUTATION_KINDS, ULW_LOOP_SUCCESS_CRITERION_USER_MODELS, UlwLoopError } from "./types.js";
 
@@ -31,6 +32,10 @@ function requiredGoal(argv: readonly string[]): string { const value = text(pars
 function readObject(value: object, key: string): unknown { return Object.entries(value).find(([name]) => name === key)?.[1]; }
 function isPlain(value: unknown): value is object { return typeof value === "object" && value !== null && !Array.isArray(value); }
 function objectText(value: object, key: string): string | undefined { const candidate = readObject(value, key); return typeof candidate === "string" ? candidate : undefined; }
+function objectStrings(value: object, key: string): string[] | undefined { const candidate = readObject(value, key); return Array.isArray(candidate) && candidate.every((item) => typeof item === "string") ? candidate : undefined; }
+function objectChildren(value: object, key: string): UlwLoopSteeringChildGoal[] | undefined { const candidate = readObject(value, key); if (!Array.isArray(candidate)) return undefined; const parsed: UlwLoopSteeringChildGoal[] = []; for (const item of candidate) { const next = child(item); if (next === null) return fail(`${key} entries require title/objective.`, "ULW_LOOP_STEERING_CHILD_INVALID", { key }); parsed.push(next); } return parsed; }
+function isProposalKind(value: unknown): value is UlwLoopSteeringMutationKind { return typeof value === "string" && ULW_LOOP_STEERING_MUTATION_KINDS.some((kind) => kind === value); }
+function isProposalSource(value: unknown): value is UlwLoopSteeringSource { return typeof value === "string" && SOURCES.some((source) => source === value); }
 
 export function parseSteeringKind(argv: readonly string[]): UlwLoopSteeringMutationKind {
 	const value = readValue(argv, "--kind");
@@ -98,6 +103,43 @@ export function normalizeSteeringProposal(proposal: CliSteeringProposal): CliSte
 	return { kind: proposal.kind, source: proposal.source, evidence, rationale, ...(goalId === undefined ? {} : { goalId }), ...(targetGoalId === undefined ? {} : { targetGoalId }), ...(targetGoalIds === undefined ? {} : { targetGoalIds }), ...(criterionId === undefined ? {} : { criterionId }), ...(title === undefined ? {} : { title }), ...(objective === undefined ? {} : { objective }), ...(childGoals === undefined ? {} : { childGoals }), ...(revisedTitle === undefined ? {} : { revisedTitle }), ...(revisedObjective === undefined ? {} : { revisedObjective }), ...(pendingOrder === undefined ? {} : { pendingOrder }), ...(blockedReason === undefined ? {} : { blockedReason }), ...(proposal.after === undefined ? {} : { after: proposal.after }), ...(directiveText === undefined ? {} : { directiveText }), ...(promptSignature === undefined ? {} : { promptSignature }), ...(idempotencyKey === undefined ? {} : { idempotencyKey }), ...(proposal.now === undefined ? {} : { now: proposal.now }), ...(scenario === undefined ? {} : { scenario }), ...(expectedEvidence === undefined ? {} : { expectedEvidence }), ...(proposal.userModel === undefined ? {} : { userModel: proposal.userModel }) };
 }
 
+export async function parseSteeringProposals(argv: readonly string[]): Promise<readonly CliSteeringProposal[]> {
+	const input = text(readValue(argv, "--proposals-json"), "--proposals-json");
+	if (input === undefined) return [await parseSteeringProposal(argv)];
+	if (readValue(argv, "--kind") !== undefined) return fail("--kind and --proposals-json are mutually exclusive.", "ULW_LOOP_STEERING_BATCH_CONFLICT", { flags: ["--kind", "--proposals-json"] });
+	const raw = await readJsonInput(input);
+	if (!Array.isArray(raw) || raw.length === 0) return fail("--proposals-json must be a non-empty JSON array.", "ULW_LOOP_STEERING_BATCH_ARRAY_REQUIRED", { flag: "--proposals-json" });
+	const proposals: CliSteeringProposal[] = [];
+	for (const item of raw) proposals.push(normalizeSteeringProposal(proposalFromObject(item)));
+	return proposals;
+}
+
+function proposalFromObject(value: unknown): CliSteeringProposal {
+	if (!isPlain(value)) return fail("--proposals-json entries must be objects.", "ULW_LOOP_STEERING_BATCH_ITEM_INVALID", { flag: "--proposals-json" });
+	const kind = readObject(value, "kind"); const source = readObject(value, "source") ?? "cli";
+	if (!isProposalKind(kind)) return fail(`Invalid batch steering kind: ${String(kind)}.`, "ULW_LOOP_STEERING_KIND_INVALID", { value: kind });
+	if (!isProposalSource(source)) return fail(`Invalid batch steering source: ${String(source)}.`, "ULW_LOOP_STEERING_SOURCE_INVALID", { value: source });
+	let proposal: CliSteeringProposal = { kind, source, evidence: objectText(value, "evidence") ?? "", rationale: objectText(value, "rationale") ?? "" };
+	const goalId = objectText(value, "goalId"); const targetGoalId = objectText(value, "targetGoalId"); const criterionId = objectText(value, "criterionId");
+	const title = objectText(value, "title"); const objective = objectText(value, "objective"); const revisedTitle = objectText(value, "revisedTitle"); const revisedObjective = objectText(value, "revisedObjective");
+	const scenario = objectText(value, "scenario"); const expectedEvidence = objectText(value, "expectedEvidence"); const idempotencyKey = objectText(value, "idempotencyKey");
+	const targetGoalIds = objectStrings(value, "targetGoalIds"); const pendingOrder = objectStrings(value, "pendingOrder"); const childGoals = objectChildren(value, "childGoals");
+	if (goalId !== undefined) proposal = { ...proposal, goalId };
+	if (targetGoalId !== undefined) proposal = { ...proposal, targetGoalId };
+	if (criterionId !== undefined) proposal = { ...proposal, criterionId };
+	if (title !== undefined) proposal = { ...proposal, title };
+	if (objective !== undefined) proposal = { ...proposal, objective };
+	if (revisedTitle !== undefined) proposal = { ...proposal, revisedTitle };
+	if (revisedObjective !== undefined) proposal = { ...proposal, revisedObjective };
+	if (scenario !== undefined) proposal = { ...proposal, scenario };
+	if (expectedEvidence !== undefined) proposal = { ...proposal, expectedEvidence };
+	if (idempotencyKey !== undefined) proposal = { ...proposal, idempotencyKey };
+	if (targetGoalIds !== undefined) proposal = { ...proposal, targetGoalIds };
+	if (pendingOrder !== undefined) proposal = { ...proposal, pendingOrder };
+	if (childGoals !== undefined) proposal = { ...proposal, childGoals };
+	return proposal;
+}
+
 export function printSteerResult(result: SteerUlwLoopResult, json: boolean): void {
 	if (json) { printJson({ ok: result.accepted, accepted: result.accepted, rejectedReasons: result.rejectedReasons, deduped: result.deduped, audit: result.audit, plan: result.plan }); return; }
 	const outcome = result.deduped ? "deduped" : result.accepted ? "accepted" : "rejected";
@@ -106,3 +148,10 @@ export function printSteerResult(result: SteerUlwLoopResult, json: boolean): voi
 	if (result.audit.idempotencyKey !== undefined) process.stdout.write(`idempotency-key: ${result.audit.idempotencyKey}\n`);
 	printStatus(result.plan);
 }
+
+export function printSteerBatchResult(result: SteerUlwLoopBatchResult, json: boolean): void {
+	if (json) { printJson({ ok: result.accepted, accepted: result.accepted, rejectedReasons: result.rejectedReasons, results: result.results, plan: result.plan }); return; }
+	process.stdout.write(`ulw-loop steer batch: ${result.accepted ? "accepted" : "rejected"} ${result.results.length} proposal(s)\n`);
+	if (result.rejectedReasons.length > 0) process.stdout.write(`rejected: ${result.rejectedReasons.join("; ")}\n`);
+	printStatus(result.plan);
+}

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

@@ -1,6 +1,5 @@
 import { readFile } from "node:fs/promises";
 
-import { type CheckpointUlwLoopArgs, checkpointUlwLoop } from "./checkpoint.js";
 import {
 	hasFlag,
 	parseCodexGoalJson,
@@ -10,7 +9,7 @@ import {
 	readValue,
 } from "./cli-arg-parser.js";
 import { blockedDecisionHandoff, normalizeCodexGoalMode, printJson, printStatus } from "./cli-output.js";
-import { parseSteeringProposal, printSteerResult } from "./cli-steering.js";
+import { parseSteeringProposals, printSteerBatchResult, printSteerResult } from "./cli-steering.js";
 import { buildCodexGoalInstruction } from "./codex-goal-instruction.js";
 import { recordEvidence } from "./evidence.js";
 import { isEssentialCriterion } from "./goal-status.js";
@@ -19,11 +18,10 @@ import { addUlwLoopGoal, createUlwLoopPlan, startNextUlwLoop, summarizeUlwLoopPl
 import { readUlwLoopPlan } from "./plan-io.js";
 import { recordFinalReviewBlockers } from "./review-blockers.js";
 import { steerUlwLoop } from "./steering.js";
+import { steerUlwLoopBatch } from "./steering-batch.js";
 import type { UlwLoopItem } from "./types.js";
 import { UlwLoopError } from "./types.js";
 
-type CheckpointStatus = "complete" | "failed" | "blocked";
-
 export async function createGoals(
 	repoRoot: string,
 	argv: readonly string[],
@@ -42,12 +40,14 @@ export async function createGoals(
 			"ULW_LOOP_BRIEF_REQUIRED",
 		);
 	}
+	const validationBatchesJson = readValue(argv, "--validation-batch-json");
 	const plan = await createUlwLoopPlan(
 		repoRoot,
 		{
 			brief,
 			codexGoalMode: normalizeCodexGoalMode(readValue(argv, "--codex-goal-mode")),
 			force: hasFlag(argv, "--force"),
+			...(validationBatchesJson === undefined ? {} : { validationBatchesJson }),
 		},
 		scope,
 	);
@@ -105,44 +105,21 @@ export async function completeGoals(
 	return 0;
 }
 
-export async function checkpoint(
-	repoRoot: string,
-	argv: readonly string[],
-	json: boolean,
-	scope?: UlwLoopScope,
-): Promise<number> {
-	const goalId = required(argv, "--goal-id");
-	const statusValue = checkpointStatus(required(argv, "--status"));
-	const evidence = required(argv, "--evidence");
-	const codexGoalJson = await parseCodexGoalJson(
-		statusValue === "complete" ? required(argv, "--codex-goal-json") : readValue(argv, "--codex-goal-json"),
-	);
-	if (statusValue === "complete" && codexGoalJson === undefined) {
-		throw new UlwLoopError("Missing --codex-goal-json.", "ULW_LOOP_CODEX_GOAL_JSON_REQUIRED");
-	}
-	const qualityGateJson = readValue(argv, "--quality-gate-json");
-	const args: CheckpointUlwLoopArgs = {
-		goalId,
-		status: statusValue,
-		evidence,
-		...(codexGoalJson === undefined ? {} : { codexGoalJson }),
-		...(qualityGateJson === undefined ? {} : { qualityGateJson }),
-	};
-	const result = await checkpointUlwLoop(repoRoot, args, scope);
-	if (json) printJson({ ok: true, ...result, summary: summarizeUlwLoopPlan(result.plan) });
-	else process.stdout.write(`ulw-loop checkpoint: ${result.goal.id} -> ${result.goal.status}\n`);
-	return 0;
-}
-
 export async function steer(
 	repoRoot: string,
 	argv: readonly string[],
 	json: boolean,
 	scope?: UlwLoopScope,
 ): Promise<number> {
-	const proposal = await parseSteeringProposal(argv);
-	const result = await steerUlwLoop(repoRoot, proposal, scope);
-	printSteerResult(result, json);
+	const proposals = await parseSteeringProposals(argv);
+	const single = proposals[0];
+	if (single !== undefined && proposals.length === 1 && readValue(argv, "--proposals-json") === undefined) {
+		const result = await steerUlwLoop(repoRoot, single, scope);
+		printSteerResult(result, json);
+		return result.accepted ? 0 : 1;
+	}
+	const result = await steerUlwLoopBatch(repoRoot, proposals, scope);
+	printSteerBatchResult(result, json);
 	return result.accepted ? 0 : 1;
 }
 
@@ -245,15 +222,6 @@ function required(argv: readonly string[], flag: string): string {
 	throw new UlwLoopError(`Missing ${flag}.`, "ULW_LOOP_ARGUMENT_MISSING", { details: { flag } });
 }
 
-function checkpointStatus(value: string): CheckpointStatus {
-	if (value === "complete" || value === "failed" || value === "blocked") return value;
-	throw new UlwLoopError(
-		"Missing or invalid --status; expected complete, failed, or blocked.",
-		"ULW_LOOP_STATUS_INVALID",
-		{ details: { status: value } },
-	);
-}
-
 function findGoal(plan: { readonly goals: readonly UlwLoopItem[] }, goalId: string): UlwLoopItem {
 	const goal = plan.goals.find((candidate) => candidate.id === goalId);
 	if (goal !== undefined) return goal;

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

@@ -1,3 +1,4 @@
+// biome-ignore-all format: long agent-facing instruction strings are intentionally stable.
 import {
 	codexGoalMode,
 	expectedCodexObjective,

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

@@ -60,5 +60,7 @@ export const ULW_LOOP_LEDGER_EVENT_KINDS = [
 	"criterion_failed",
 	"criterion_blocked",
 	"criteria_revised",
+	"batch_closed",
+	"batch_updated",
 ] as const satisfies readonly string[];
 export type UlwLoopLedgerEventKind = (typeof ULW_LOOP_LEDGER_EVENT_KINDS)[number];

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

@@ -55,6 +55,12 @@ export interface UlwLoopAggregateCompletion {
 	codexGoal?: unknown;
 }
 
+export interface UlwLoopValidationBatch {
+	readonly batchId: string;
+	readonly memberIds: readonly string[];
+	readonly finalGoalId: string;
+}
+
 export interface UlwLoopPlan {
 	version: 1;
 	evidenceLayoutVersion?: 2;
@@ -68,6 +74,7 @@ export interface UlwLoopPlan {
 	codexObjectiveAliases?: string[];
 	aggregateCompletion?: UlwLoopAggregateCompletion;
 	activeGoalId?: string;
+	validationBatches?: readonly UlwLoopValidationBatch[];
 	goals: UlwLoopItem[];
 }
 

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

@@ -21,6 +21,10 @@ function isResolvedStatus(status: UlwLoopStatus): boolean {
 	return status === "complete";
 }
 
+export function isMemberResolved(goal: UlwLoopItem, plan: UlwLoopPlan): boolean {
+	return isResolvedStatus(goal.status) || isSupersededResolved(goal, plan);
+}
+
 function isSupersededResolved(goal: UlwLoopItem, plan: UlwLoopPlan): boolean {
 	if (goal.steeringStatus !== "superseded") return false;
 	const replacements = goal.supersededBy ?? [];

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

@@ -16,6 +16,7 @@ import { appendGoalToPlan, deriveGoalCandidates, makeGoal } from "./plan-goal-fa
 import { appendLedger, readUlwLoopPlan, withUlwLoopMutationLock, writePlan } from "./plan-io.js";
 import type { UlwLoopCodexGoalMode, UlwLoopItem, UlwLoopPlan, UlwLoopSuccessCriterion } from "./types.js";
 import { iso, UlwLoopError } from "./types.js";
+import { parseValidationBatches } from "./validation-batch.js";
 
 export { deriveGoalCandidates, seedDefaultSuccessCriteria } from "./plan-goal-factory.js";
 
@@ -57,7 +58,7 @@ function clearGoalBlockerFields(goal: UlwLoopItem): void {
 
 export async function createUlwLoopPlan(
 	repoRoot: string,
-	args: { brief: string; codexGoalMode?: UlwLoopCodexGoalMode; force?: boolean },
+	args: { brief: string; codexGoalMode?: UlwLoopCodexGoalMode; force?: boolean; validationBatchesJson?: string },
 	scope?: UlwLoopScope,
 ): Promise<UlwLoopPlan> {
 	return withUlwLoopMutationLock(repoRoot, scope, async () => {
@@ -84,6 +85,8 @@ export async function createUlwLoopPlan(
 			codexGoalMode: args.codexGoalMode ?? "aggregate",
 			goals,
 		};
+		const validationBatches = await parseValidationBatches(args.validationBatchesJson, goals);
+		if (validationBatches !== undefined) plan.validationBatches = validationBatches;
 		if (plan.codexGoalMode === "aggregate") plan.codexObjective = aggregateCodexObjectiveForScope(scope);
 		await mkdir(ulwLoopDir(repoRoot, scope), { recursive: true });
 		await writeFile(

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

@@ -27,7 +27,12 @@ function isLegacyEnumeratedAggregateObjective(objective: string | undefined): ob
 }
 
 function isSteeringKind(value: unknown): value is UlwLoopLedgerEntry["kind"] {
-	return value === "steering_accepted" || value === "steering_rejected" || value === "criteria_revised";
+	return (
+		value === "steering_accepted" ||
+		value === "steering_rejected" ||
+		value === "criteria_revised" ||
+		value === "batch_updated"
+	);
 }
 
 export async function withUlwLoopMutationLock<T>(repoRoot: string, fn: () => Promise<T>): Promise<T>;
@@ -112,8 +117,21 @@ export async function writePlan(repoRoot: string, plan: UlwLoopPlan, scope?: Ulw
 }
 
 export async function appendLedger(repoRoot: string, entry: UlwLoopLedgerEntry, scope?: UlwLoopScope): Promise<void> {
+	await appendLedgerEntries(repoRoot, [entry], scope);
+}
+
+export async function appendLedgerEntries(
+	repoRoot: string,
+	entries: readonly UlwLoopLedgerEntry[],
+	scope?: UlwLoopScope,
+): Promise<void> {
+	if (entries.length === 0) return;
 	await mkdir(ulwLoopDir(repoRoot, scope), { recursive: true });
-	await appendFile(ulwLoopLedgerPath(repoRoot, scope), `${JSON.stringify(entry)}\n`, "utf8");
+	await appendFile(
+		ulwLoopLedgerPath(repoRoot, scope),
+		`${entries.map((entry) => JSON.stringify(entry)).join("\n")}\n`,
+		"utf8",
+	);
 }
 
 /**

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

@@ -1,4 +1,4 @@
-import { literal, invalid, textField } from "./quality-gate-fields.js";
+import { invalid, literal, textField } from "./quality-gate-fields.js";
 
 export function passedVerdict(value: unknown, field: string): "passed" {
 	if (value === "not_applicable") invalid(`${field} must not be not_applicable.`, field);