oh-my-opencode 4.19.0 → 4.19.2

package/packages/omo-codex/plugin/components/ulw-loop/dist/checkpoint-continuation.js

@@ -0,0 +1,64 @@
+import { checkpointUlwLoop } from "./checkpoint.js";
+import { hasFlag, parseCodexGoalJson, readValue } from "./cli-arg-parser.js";
+import { blockedDecisionHandoff, printJson } from "./cli-output.js";
+import { buildCodexGoalInstruction } from "./codex-goal-instruction.js";
+import { startNextUlwLoop, summarizeUlwLoopPlan } from "./plan-crud.js";
+import { UlwLoopError } from "./types.js";
+export async function checkpointAndContinue(repoRoot, args, scope) {
+    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, argv, json, scope) {
+    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 = {
+        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) {
+    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) {
+    const handoff = blockedDecisionHandoff(plan);
+    return { done: true, blocked: handoff.length > 0, handoff };
+}
+function required(argv, flag) {
+    const value = readValue(argv, flag)?.trim();
+    if (value)
+        return value;
+    throw new UlwLoopError(`Missing ${flag}.`, "ULW_LOOP_ARGUMENT_MISSING", { details: { flag } });
+}
+function checkpointStatus(value) {
+    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/dist/checkpoint.js

@@ -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";
@@ -6,9 +6,11 @@ import { buildTaskScopedAggregateReconciliationHint, canReconcileActiveFinalTask
 import { formatCodexGoalReconciliation, readCodexGoalSnapshotInput, reconcileCodexGoalSnapshot, } from "./codex-goal-snapshot.js";
 import { requireAllCriteriaPass, requireAllPlanCriteriaPass, requireEssentialCriteriaPass } from "./evidence.js";
 import { codexGoalMode, compatibleCodexObjectives, expectedCodexObjective, isFinalRunCompletionCandidate, } from "./goal-status.js";
+import { ulwLoopAttemptEvidenceDir } from "./paths.js";
 import { appendLedger, readUlwLoopPlan, withUlwLoopMutationLock, writePlan } from "./plan-io.js";
 import { classifyExternalAuthorizationBlocker, clearGoalBlockerFields, sameBlockerOccurrences, validateQualityGate, } from "./quality-gate.js";
 import { iso, UlwLoopError } from "./types.js";
+import { batchClosedBy, requireAllValidationBatchesClosed, requireBatchFinalReady, requireBatchGate } from "./validation-batch.js";
 const QUALITY_GATE_FS = { existsSync, statSync };
 function ulwLoopFail(message, code) {
     throw new UlwLoopError(message, code);
@@ -112,9 +114,11 @@ export async function checkpointUlwLoop(repoRoot, args, scope) {
         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);
@@ -144,9 +148,13 @@ export async function checkpointUlwLoop(repoRoot, args, scope) {
                 if (!taskScoped)
                     throw new UlwLoopError(`${formatCodexGoalReconciliation(reconciliation)}${aggregate && snapshot?.status === "complete" && objective !== undefined ? buildTaskScopedAggregateReconciliationHint(goal, final) : ""}`, "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,
@@ -154,6 +162,8 @@ export async function checkpointUlwLoop(repoRoot, args, scope) {
                         ? { currentAttemptDir: ulwLoopAttemptEvidenceDir(goal.id, goal.attempt, scope) }
                         : {}),
                 });
+                requireBatchGate(plan, goal, qualityGate);
+            }
             goal.status = "complete";
             goal.completedAt = now;
             goal.evidence = evidence;
@@ -172,6 +182,9 @@ export async function checkpointUlwLoop(repoRoot, args, scope) {
         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/dist/cli-arg-parser.js

@@ -1,7 +1,7 @@
 // biome-ignore-all format: keep this module under the mandated pure LOC budget.
 import { readFile } from "node:fs/promises";
 import { UlwLoopError } from "./types.js";
-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, flag) { return argv.includes(flag); }
 export function readValue(argv, flag) {

package/packages/omo-codex/plugin/components/ulw-loop/dist/cli-commands.js

@@ -1,6 +1,7 @@
+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, reviewBlockers, status, steer, } from "./cli-subcommands.js";
+import { addGoal, captureEvidence, completeGoals, createGoals, criteria, reviewBlockers, status, steer, } from "./cli-subcommands.js";
 import { resolveUlwLoopSessionIdFromEnv } from "./paths.js";
 import { UlwLoopError } from "./types.js";
 export const ULW_LOOP_SUBCOMMANDS = [

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

@@ -1,5 +1,5 @@
 import type { UlwLoopCodexGoalMode, UlwLoopPlan } from "./types.js";
-export declare const ULW_LOOP_HELP = "Usage:\n  omo ulw-loop create-goals --brief \"...\" [--brief-file <path>] [--from-stdin] [--codex-goal-mode aggregate|per_story] [--force] [--json]\n  omo ulw-loop status [--json]\n  omo ulw-loop complete-goals [--retry-failed] [--json]\n  omo ulw-loop criteria --goal-id <id> [--json]\n  omo ulw-loop record-evidence --goal-id <id> --criterion-id <id> --status pass|fail|blocked --evidence \"...\" [--notes \"...\"] [--json]\n  omo ulw-loop checkpoint --goal-id <id> --status complete|failed|blocked --evidence \"...\" --codex-goal-json <...> [--quality-gate-json <...>] [--json]\n  omo ulw-loop steer --kind <kind> ... --evidence \"...\" --rationale \"...\" [--json]\n  omo ulw-loop add-goal --title \"...\" --objective \"...\" [--json]\n  omo ulw-loop record-review-blockers --goal-id <id> --title \"...\" --objective \"...\" --evidence \"...\" --codex-goal-json <...> [--json]\n\nAll subcommands accept [--session-id <id>] to isolate state under .omo/ulw-loop/<id>/; without it, Codex session env is used when present.";
+export declare const ULW_LOOP_HELP = "Usage:\n  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]\n  omo ulw-loop status [--json]\n  omo ulw-loop complete-goals [--retry-failed] [--json]\n  omo ulw-loop criteria --goal-id <id> [--json]\n  omo ulw-loop record-evidence --goal-id <id> --criterion-id <id> --status pass|fail|blocked --evidence \"...\" [--notes \"...\"] [--json]\n  omo ulw-loop checkpoint --goal-id <id> --status complete|failed|blocked --evidence \"...\" --codex-goal-json <...> [--quality-gate-json <...>] [--no-advance] [--json]\n  omo ulw-loop steer --kind <kind> ... --evidence \"...\" --rationale \"...\" [--proposals-json <json-or-path>] [--json]\n  omo ulw-loop add-goal --title \"...\" --objective \"...\" [--json]\n  omo ulw-loop record-review-blockers --goal-id <id> --title \"...\" --objective \"...\" --evidence \"...\" --codex-goal-json <...> [--json]\n\nAll subcommands accept [--session-id <id>] to isolate state under .omo/ulw-loop/<id>/; without it, Codex session env is used when present.";
 export declare function printJson(value: unknown): void;
 export declare function printJsonError(error: unknown): void;
 export declare function printStatus(plan: UlwLoopPlan): void;

package/packages/omo-codex/plugin/components/ulw-loop/dist/cli-output.js

@@ -1,12 +1,12 @@
 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/dist/cli-steering.d.ts

@@ -1,3 +1,4 @@
+import type { SteerUlwLoopBatchResult } from "./steering-batch.js";
 import type { SteerUlwLoopResult, UlwLoopSteeringMutationKind, UlwLoopSteeringProposal, UlwLoopSteeringSource, UlwLoopSuccessCriterionUserModel } from "./types.js";
 export type CliSteeringProposal = UlwLoopSteeringProposal & {
     readonly goalId?: string;
@@ -9,4 +10,6 @@ export declare function parseSteeringKind(argv: readonly string[]): UlwLoopSteer
 export declare function parseSteeringSource(argv: readonly string[]): UlwLoopSteeringSource;
 export declare function parseSteeringProposal(argv: readonly string[]): Promise<CliSteeringProposal>;
 export declare function normalizeSteeringProposal(proposal: CliSteeringProposal): CliSteeringProposal;
+export declare function parseSteeringProposals(argv: readonly string[]): Promise<readonly CliSteeringProposal[]>;
 export declare function printSteerResult(result: SteerUlwLoopResult, json: boolean): void;
+export declare function printSteerBatchResult(result: SteerUlwLoopBatchResult, json: boolean): void;

package/packages/omo-codex/plugin/components/ulw-loop/dist/cli-steering.js

@@ -28,6 +28,16 @@ function requiredGoal(argv) { const value = text(parseGoalArg(argv), "--goal-id"
 function readObject(value, key) { return Object.entries(value).find(([name]) => name === key)?.[1]; }
 function isPlain(value) { return typeof value === "object" && value !== null && !Array.isArray(value); }
 function objectText(value, key) { const candidate = readObject(value, key); return typeof candidate === "string" ? candidate : undefined; }
+function objectStrings(value, key) { const candidate = readObject(value, key); return Array.isArray(candidate) && candidate.every((item) => typeof item === "string") ? candidate : undefined; }
+function objectChildren(value, key) { const candidate = readObject(value, key); if (!Array.isArray(candidate))
+    return undefined; const parsed = []; 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) { return typeof value === "string" && ULW_LOOP_STEERING_MUTATION_KINDS.some((kind) => kind === value); }
+function isProposalSource(value) { return typeof value === "string" && SOURCES.some((source) => source === value); }
 export function parseSteeringKind(argv) {
     const value = readValue(argv, "--kind");
     if (isKind(value))
@@ -144,6 +154,71 @@ export function normalizeSteeringProposal(proposal) {
     const pendingOrder = normalizedStrings(proposal.pendingOrder, "pendingOrder");
     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) {
+    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 = [];
+    for (const item of raw)
+        proposals.push(normalizeSteeringProposal(proposalFromObject(item)));
+    return proposals;
+}
+function proposalFromObject(value) {
+    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 = { 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, json) {
     if (json) {
         printJson({ ok: result.accepted, accepted: result.accepted, rejectedReasons: result.rejectedReasons, deduped: result.deduped, audit: result.audit, plan: result.plan });
@@ -157,3 +232,13 @@ export function printSteerResult(result, json) {
         process.stdout.write(`idempotency-key: ${result.audit.idempotencyKey}\n`);
     printStatus(result.plan);
 }
+export function printSteerBatchResult(result, json) {
+    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/dist/cli-subcommands.d.ts

@@ -2,7 +2,6 @@ import { type UlwLoopScope } from "./paths.js";
 export declare function createGoals(repoRoot: string, argv: readonly string[], json: boolean, scope?: UlwLoopScope): Promise<number>;
 export declare function status(repoRoot: string, json: boolean, scope?: UlwLoopScope): Promise<number>;
 export declare function completeGoals(repoRoot: string, argv: readonly string[], json: boolean, scope?: UlwLoopScope): Promise<number>;
-export declare function checkpoint(repoRoot: string, argv: readonly string[], json: boolean, scope?: UlwLoopScope): Promise<number>;
 export declare function steer(repoRoot: string, argv: readonly string[], json: boolean, scope?: UlwLoopScope): Promise<number>;
 export declare function addGoal(repoRoot: string, argv: readonly string[], json: boolean, scope?: UlwLoopScope): Promise<number>;
 export declare function criteria(repoRoot: string, argv: readonly string[], json: boolean, scope?: UlwLoopScope): Promise<number>;

package/packages/omo-codex/plugin/components/ulw-loop/dist/cli-subcommands.js

@@ -1,8 +1,7 @@
 import { readFile } from "node:fs/promises";
-import { checkpointUlwLoop } from "./checkpoint.js";
 import { hasFlag, parseCodexGoalJson, parseRecordEvidenceArgs, positionalText, readStdin, 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";
@@ -11,6 +10,7 @@ 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 { UlwLoopError } from "./types.js";
 export async function createGoals(repoRoot, argv, json, scope) {
     const briefFile = readValue(argv, "--brief-file");
@@ -21,10 +21,12 @@ export async function createGoals(repoRoot, argv, json, scope) {
     if (!brief.trim()) {
         throw new UlwLoopError("Missing brief text. Pass --brief, --brief-file, --from-stdin, or positional text.", "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);
     if (json)
         printJson({ ok: true, plan, summary: summarizeUlwLoopPlan(plan) });
@@ -76,33 +78,16 @@ export async function completeGoals(repoRoot, argv, json, scope) {
         process.stdout.write(`${instruction.text}\n`);
     return 0;
 }
-export async function checkpoint(repoRoot, argv, json, scope) {
-    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 = {
-        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, argv, json, scope) {
-    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;
 }
 export async function addGoal(repoRoot, argv, json, scope) {
@@ -171,11 +156,6 @@ function required(argv, flag) {
         return value;
     throw new UlwLoopError(`Missing ${flag}.`, "ULW_LOOP_ARGUMENT_MISSING", { details: { flag } });
 }
-function checkpointStatus(value) {
-    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, goalId) {
     const goal = plan.goals.find((candidate) => candidate.id === goalId);
     if (goal !== undefined)