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

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

@@ -1,14 +1,10 @@
 #!/usr/bin/env node
 
 // components/ulw-loop/src/checkpoint.ts
-import { existsSync as existsSync4, statSync as statSync2 } from "node:fs";
-import { readFile as readFile5 } from "node:fs/promises";
+import { existsSync as existsSync3, statSync as statSync2 } from "node:fs";
+import { readFile as readFile4 } from "node:fs/promises";
 import { resolve as resolve3 } from "node:path";
 
-// components/ulw-loop/src/checkpoint-reconciliation.ts
-import { existsSync as existsSync2 } from "node:fs";
-import { readFile as readFile2 } from "node:fs/promises";
-
 // components/ulw-loop/src/codex-goal-snapshot.ts
 import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
@@ -20,16 +16,25 @@ function safeObject(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 function safeString(value) {
+  return typeof value === "string" ? value : "";
+}
+function safeStatusString(value) {
   return typeof value === "string" ? value.trim() : "";
 }
 function normalizeStatus(value) {
-  const status = safeString(value).toLowerCase();
+  const status = safeStatusString(value).toLowerCase();
   if (status === "complete" || status === "completed" || status === "done")
     return "complete";
   if (status === "cancelled" || status === "canceled")
     return "cancelled";
   if (status === "failed" || status === "failure")
     return "failed";
+  if (status === "paused")
+    return "paused";
+  if (status === "usage_limited")
+    return "usage_limited";
+  if (status === "budget_limited")
+    return "budget_limited";
   if (status === "active" || status === "in_progress" || status === "pending" || status === "running")
     return "active";
   return "unknown";
@@ -75,46 +80,32 @@ function reconcileCodexGoalSnapshot(snapshot, options) {
   const effectiveSnapshot = snapshot ?? { available: false, raw: null };
   const errors = [];
   const warnings = [];
+  const expected = options.expectedObjective;
+  const normalizedExpected = normalizeObjective(expected);
   if (!effectiveSnapshot.available) {
-    const message = "Codex goal snapshot is absent or reports no active goal; call get_goal and pass its JSON with --codex-goal-json.";
-    if (options.requireSnapshot)
-      errors.push(message);
-    else
-      warnings.push(message);
+    warnings.push(`call get_goal; if none, create_goal with codexObjective "${expected}" verbatim`);
     return { ok: errors.length === 0, snapshot: effectiveSnapshot, warnings, errors };
   }
-  const expected = normalizeObjective(options.expectedObjective);
-  const accepted = new Set([expected, ...(options.acceptedObjectives ?? []).map((objective) => normalizeObjective(objective))].filter(Boolean));
+  const accepted = new Set([
+    normalizedExpected,
+    ...(options.acceptedObjectives ?? []).map((objective) => normalizeObjective(objective))
+  ].filter(Boolean));
   const actual = normalizeObjective(effectiveSnapshot.objective ?? "");
-  if (!actual) {
-    errors.push("Codex goal snapshot is missing objective text.");
-  } else if (!accepted.has(actual)) {
-    errors.push(`Codex goal objective mismatch: expected "${expected}", got "${actual}".`);
+  if (actual && !accepted.has(normalizeObjective(actual))) {
+    warnings.push(`driver_objective_differs: expected "${expected}", got "${actual}".`);
   }
-  const allowed = options.allowedStatuses ?? (options.requireComplete ? ["complete"] : ["active", "complete"]);
   const actualStatus = effectiveSnapshot.status ?? "unknown";
-  if (!allowed.includes(actualStatus)) {
-    errors.push(`Codex goal status mismatch: expected ${allowed.join(" or ")}, got ${actualStatus}.`);
-  }
-  if (options.requireComplete && actualStatus !== "complete") {
-    errors.push('Codex goal is not complete; call update_goal({status: "complete"}) only after the objective is actually complete, then pass the fresh get_goal JSON.');
+  if (actualStatus === "paused" || actualStatus === "usage_limited" || actualStatus === "budget_limited") {
+    warnings.push("/goal resume or raise the budget");
   }
+  if (actualStatus === "complete")
+    warnings.push(`driver closed early: call create_goal with codexObjective "${expected}" verbatim`);
   return { ok: errors.length === 0, snapshot: effectiveSnapshot, warnings, errors };
 }
 function formatCodexGoalReconciliation(reconciliation) {
   const parts = [...reconciliation.errors, ...reconciliation.warnings];
   return parts.join(" ");
 }
-function codexGoalMismatchRecovery(expectedObjective, snapshot) {
-  const receivedObjective = snapshot?.objective ?? "";
-  const message = [
-    "Recovery: the Codex goal objective must equal the plan's codexObjective exactly — copy the expected value below into update_goal and re-run get_goal.",
-    `expected codexObjective: ${expectedObjective}`,
-    `received objective: ${receivedObjective || "(none)"}`
-  ].join(`
-`);
-  return { message, details: { expectedObjective, receivedObjective } };
-}
 
 // components/ulw-loop/src/paths.ts
 import { isAbsolute, join, relative, sep } from "node:path";
@@ -308,114 +299,21 @@ function hasEssentialCriteriaPass(goal) {
   return criteria.length > 0 && criteria.every((criterion) => criterion.status === "pass");
 }
 
-// components/ulw-loop/src/checkpoint-reconciliation.ts
-function codexSnapshotMismatchError(input) {
-  const { reconciliation, snapshot, taskScopedHint } = input;
-  const hint = taskScopedHint?.aggregate === true && snapshot?.status === "complete" && snapshot.objective !== undefined ? buildTaskScopedAggregateReconciliationHint(taskScopedHint.goal, taskScopedHint.final) : "";
-  const recovery = codexGoalMismatchRecovery(input.expectedObjective, snapshot);
-  return new UlwLoopError(`${formatCodexGoalReconciliation(reconciliation)}${hint}
-${recovery.message}`, "ulw_loop_codex_snapshot_mismatch", { details: recovery.details });
-}
-function normalizeObjective2(value) {
-  return value.replace(/\s+/g, " ").trim();
-}
-function textMentionsUlwLoopPlanArtifact(value) {
-  const normalized = (value ?? "").toLowerCase();
-  return normalized.includes(ULW_LOOP_DIR.toLowerCase()) || normalized.includes(ULW_LOOP_GOALS.toLowerCase()) || normalized.includes(ULW_LOOP_LEDGER.toLowerCase());
-}
-function textMentionsGoalId(value, goalId) {
-  return (value ?? "").toLowerCase().includes(goalId.toLowerCase());
-}
-function textHasCompletionValidationEvidence(value) {
-  const normalized = (value ?? "").toLowerCase();
-  const done = /\b(?:planned work|implementation|deliverables?|scope|task|work)\b/.test(normalized) && /\b(?:done|complete|completed|finished|shipped)\b/.test(normalized);
-  const verified = /\b(?:validation|verification|tests?|build|lint|review|quality gate|code-review)\b/.test(normalized) && /\b(?:passed|complete|completed|clean|green|approve|approved|clear)\b/.test(normalized);
-  return done && verified;
-}
-async function snapshotObjectiveMapsToUlwLoopPlan(repoRoot, snapshotObjective, scope) {
-  const actual = normalizeObjective2(snapshotObjective).toLowerCase();
-  if (textMentionsUlwLoopPlanArtifact(actual))
-    return true;
-  if (actual.length < 24 || !existsSync2(ulwLoopBriefPath(repoRoot, scope)))
-    return false;
-  try {
-    const brief = normalizeObjective2(await readFile2(ulwLoopBriefPath(repoRoot, scope), "utf8")).toLowerCase();
-    return brief.length >= 24 && (brief.includes(actual) || actual.includes(brief));
-  } catch (error) {
-    if (error instanceof Error)
-      return false;
-    throw error;
-  }
-}
-async function canReconcileCompletedTaskScopedAggregateSnapshot(repoRoot, plan, goal, snapshotObjective, evidence, scope) {
-  if (codexGoalMode(plan) !== "aggregate")
-    return false;
-  if (goal.status !== "in_progress" || plan.activeGoalId !== goal.id)
-    return false;
-  if (isFinalRunCompletionCandidate(plan, goal)) {
-    return snapshotObjectiveMapsToUlwLoopPlan(repoRoot, snapshotObjective, scope);
-  }
-  if (!textMentionsUlwLoopPlanArtifact(evidence) || !textMentionsGoalId(evidence, goal.id))
-    return false;
-  if (!textHasCompletionValidationEvidence(evidence))
-    return false;
-  return snapshotObjectiveMapsToUlwLoopPlan(repoRoot, snapshotObjective, scope);
-}
-async function canReconcileActiveFinalTaskScopedAggregateSnapshot(repoRoot, plan, goal, snapshotObjective, evidence, scope) {
-  if (codexGoalMode(plan) !== "aggregate")
-    return false;
-  if (goal.status !== "in_progress" || plan.activeGoalId !== goal.id)
-    return false;
-  if (!isFinalRunCompletionCandidate(plan, goal))
-    return false;
-  if (!textHasCompletionValidationEvidence(evidence))
-    return false;
-  return snapshotObjectiveMapsToUlwLoopPlan(repoRoot, snapshotObjective, scope);
-}
-function buildCompletedLegacyGoalRemediation(goal) {
-  return [
-    "If get_goal returns a different completed legacy/thread objective, do not repeat --status complete in this thread.",
-    `Record a non-terminal blocker with: omo-agent-toolkit ulw-loop checkpoint --goal-id ${goal.id} --status blocked --evidence "<completed legacy Codex goal blocks create_goal in this thread>" --codex-goal-json "<different completed get_goal JSON or path>".`,
-    "Then continue only from a Codex goal context with no active/completed conflicting goal, in the same repo/worktree, and create the intended goal there."
-  ].join(" ");
-}
-function buildTaskScopedAggregateReconciliationHint(goal, final) {
-  if (final) {
-    return ` Final task-scoped aggregate reconciliation requires the checkpoint goal to be the active in-progress final OMO goal and the completed get_goal objective to map to the ulw-loop brief or artifact. ${buildCompletedLegacyGoalRemediation(goal)}`;
-  }
-  return ` Completed task-scoped aggregate reconciliation requires the checkpoint goal to be the active in-progress OMO goal, evidence that names that active OMO goal id, names .omo/ulw-loop/goals.json or ledger.jsonl, includes completed implementation plus validation/review evidence, and a get_goal objective that maps to the ulw-loop brief/artifact. ${buildCompletedLegacyGoalRemediation(goal)}`;
-}
-
 // components/ulw-loop/src/checkpoint-codex-validation.ts
-function normalizeObjective3(value) {
-  return value.replace(/\s+/g, " ").trim();
-}
 async function validateCheckpointCodexGoal(input) {
-  const aggregate = codexGoalMode(input.plan) === "aggregate";
-  const final = isFinalRunCompletionCandidate(input.plan, input.goal);
   const snapshot = await readCodexGoalSnapshotInput(input.raw, input.repoRoot);
-  const expectedObjective = expectedCodexObjective(input.plan, input.goal);
+  const expected = expectedCodexObjective(input.plan, input.goal);
   const reconciliation = reconcileCodexGoalSnapshot(snapshot, {
-    expectedObjective,
-    ...aggregate ? { acceptedObjectives: compatibleCodexObjectives(input.plan) } : {},
-    allowedStatuses: aggregate ? final ? ["complete"] : ["active"] : ["complete"],
-    requireSnapshot: true,
-    requireComplete: !aggregate || final
-  });
-  if (reconciliation.ok)
-    return reconciliation.snapshot.raw;
-  const objective = snapshot?.objective;
-  const mismatchedTaskObjective = snapshot?.available === true && objective !== undefined && normalizeObjective3(objective) !== normalizeObjective3(expectedObjective);
-  const completedTaskScoped = mismatchedTaskObjective && snapshot.status === "complete" && await canReconcileCompletedTaskScopedAggregateSnapshot(input.repoRoot, input.plan, input.goal, objective, input.evidence, input.scope);
-  const activeFinalTaskScoped = mismatchedTaskObjective && snapshot.status === "active" && await canReconcileActiveFinalTaskScopedAggregateSnapshot(input.repoRoot, input.plan, input.goal, objective, input.evidence, input.scope);
-  if (completedTaskScoped || activeFinalTaskScoped)
-    return reconciliation.snapshot.raw;
-  throw codexSnapshotMismatchError({
-    reconciliation,
-    snapshot,
-    expectedObjective,
-    taskScopedHint: { goal: input.goal, aggregate, final }
+    expectedObjective: expected,
+    ...codexGoalMode(input.plan) === "aggregate" ? { acceptedObjectives: compatibleCodexObjectives(input.plan) } : {}
   });
+  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"))
+  };
 }
 function combineCheckpointValidationErrors(codexError, gateError) {
   return new UlwLoopError(`${codexError.message}
@@ -427,7 +325,7 @@ ${gateError.message}`, "ULW_LOOP_QUALITY_GATE_INVALID", {
 // components/ulw-loop/src/plan-io.ts
 import { AsyncLocalStorage } from "node:async_hooks";
 import { createReadStream, readdirSync } from "node:fs";
-import { appendFile, mkdir, readFile as readFile3, rename, writeFile } from "node:fs/promises";
+import { appendFile, mkdir, readFile as readFile2, rename, writeFile } from "node:fs/promises";
 import { createInterface } from "node:readline";
 
 // components/ulw-loop/src/plan-missing-recovery.ts
@@ -694,7 +592,7 @@ async function readUlwLoopPlan(repoRoot, scope) {
   const path = ulwLoopGoalsPath(repoRoot, scope);
   let raw;
   try {
-    raw = await readFile3(path, "utf8");
+    raw = await readFile2(path, "utf8");
   } catch (error) {
     if (!hasCode2(error, "ENOENT"))
       throw error;
@@ -1113,7 +1011,7 @@ function adversarialVerdict(row, field) {
 }
 
 // components/ulw-loop/src/surface.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
 import { dirname as dirname2, join as join2 } from "node:path";
 import { fileURLToPath } from "node:url";
 var REVIEWER_ROLES_BY_SURFACE = {
@@ -1173,7 +1071,7 @@ function resolveToolkitSurface(options) {
 }
 function readMarkerSurface(markerPath) {
   try {
-    if (!existsSync3(markerPath))
+    if (!existsSync2(markerPath))
       return null;
     const parsed = JSON.parse(readFileSync2(markerPath, "utf8"));
     return parseSurface(parsed["surface"]);
@@ -1376,7 +1274,7 @@ function parseAdversarialCases(value, byId) {
 }
 
 // components/ulw-loop/src/cli-arg-parser.ts
-import { readFile as readFile4 } from "node:fs/promises";
+import { readFile as readFile3 } from "node:fs/promises";
 var 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(" "));
 var SUBCOMMANDS = new Set("create-goals status complete-goals criteria record-evidence checkpoint steer add-goal record-review-blockers".split(" "));
 function hasFlag(argv, flag) {
@@ -1424,7 +1322,7 @@ async function readJsonInput(value) {
   if (value === undefined)
     return;
   try {
-    return JSON.parse(looksLikeJson(value) ? value : await readFile4(value, "utf8"));
+    return JSON.parse(looksLikeJson(value) ? value : await readFile3(value, "utf8"));
   } catch (error) {
     const message = error instanceof Error ? error.message : "unknown error";
     throw new UlwLoopError(`Invalid JSON input: ${message}`, "ULW_LOOP_JSON_INPUT_INVALID", { cause: error });
@@ -1433,13 +1331,13 @@ async function readJsonInput(value) {
 async function parseCodexGoalJson(value) {
   if (value === undefined)
     return;
-  const raw = looksLikeJson(value) ? value : await readFile4(value, "utf8");
   try {
+    const raw = looksLikeJson(value) ? value : await readFile3(value, "utf8");
     JSON.parse(raw);
     return raw;
   } catch (error) {
     const message = error instanceof Error ? error.message : "unknown error";
-    throw new UlwLoopError(`Invalid --codex-goal-json: ${message}`, "ULW_LOOP_CODEX_GOAL_JSON_INVALID", { cause: error });
+    throw new UlwLoopError(`Invalid --codex-goal-json: ${looksLikeJson(value) ? message : "neither valid JSON nor a readable path"}`, "ULW_LOOP_CODEX_GOAL_JSON_INVALID", { cause: error });
   }
 }
 function required(argv, flag, code) {
@@ -1585,7 +1483,7 @@ function fail(message, code = "ULW_LOOP_VALIDATION_BATCH_INVALID") {
 }
 
 // components/ulw-loop/src/checkpoint.ts
-var QUALITY_GATE_FS = { existsSync: existsSync4, statSync: statSync2 };
+var QUALITY_GATE_FS = { existsSync: existsSync3, statSync: statSync2 };
 function ulwLoopFail2(message, code) {
   throw new UlwLoopError(message, code);
 }
@@ -1608,10 +1506,10 @@ async function readJsonInput2(raw, repoRoot) {
       throw error;
   }
   const path = resolve3(repoRoot, trimmed);
-  if (!existsSync4(path))
+  if (!existsSync3(path))
     return ulwLoopFail2("Quality gate JSON is neither valid JSON nor a readable path.", "ulw_loop_json_input_invalid");
   try {
-    return JSON.parse(await readFile5(path, "utf8"));
+    return JSON.parse(await readFile4(path, "utf8"));
   } catch (error) {
     return ulwLoopFail2(`Quality gate path does not contain valid JSON${error instanceof Error ? `: ${error.message}` : "."}`, "ulw_loop_json_input_invalid");
   }
@@ -1680,6 +1578,8 @@ async function checkpointUlwLoop(repoRoot, args, scope) {
     let aggregateCompletion;
     let qualityGate;
     let codexGoal;
+    let nextActions = [];
+    let warnings = [];
     if (args.status === "complete") {
       const aggregate = codexGoalMode(plan) === "aggregate";
       const final = isFinalRunCompletionCandidate(plan, goal);
@@ -1694,7 +1594,7 @@ async function checkpointUlwLoop(repoRoot, args, scope) {
         requireAllCriteriaPass(goal);
       let codexValidationError;
       try {
-        codexGoal = await validateCheckpointCodexGoal({
+        const validation = await validateCheckpointCodexGoal({
           repoRoot,
           plan,
           goal,
@@ -1702,6 +1602,9 @@ async function checkpointUlwLoop(repoRoot, args, scope) {
           evidence,
           ...scope === undefined ? {} : { scope }
         });
+        codexGoal = validation.raw;
+        nextActions = validation.nextActions;
+        warnings = validation.warnings;
       } catch (error) {
         if (!(error instanceof UlwLoopError))
           throw error;
@@ -1743,6 +1646,8 @@ async function checkpointUlwLoop(repoRoot, args, scope) {
     goal.updatedAt = now;
     if (aggregateCompletion !== undefined)
       plan.aggregateCompletion = aggregateCompletion;
+    if (aggregateCompletion !== undefined)
+      nextActions = [...nextActions, 'aggregate complete — now update_goal({status:"complete"})'];
     plan.updatedAt = now;
     await writePlan(repoRoot, plan, scope);
     const ledgerEntry = buildLedger(now, args, goal, qualityGate, codexGoal, aggregateCompletion);
@@ -1750,7 +1655,7 @@ async function checkpointUlwLoop(repoRoot, args, 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 };
+    return aggregateCompletion === undefined ? { plan, goal, ledgerEntry, nextActions, warnings } : { plan, goal, ledgerEntry, aggregateCompletion, nextActions, warnings };
   });
 }
 
@@ -2085,14 +1990,14 @@ function joinLines(lines) {
 }
 
 // components/ulw-loop/src/plan-crud.ts
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync4 } from "node:fs";
 import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
 
 // components/ulw-loop/src/plan-goal-factory.ts
 function cleanLine(line) {
   return line.replace(/^\s*(?:[-*+]\s+|\d+[.)]\s+)/, "").trim();
 }
-function normalizeObjective4(value) {
+function normalizeObjective2(value) {
   return value.replace(/\s+/g, " ").trim();
 }
 function titleFromObjective(objective, fallback) {
@@ -2113,7 +2018,7 @@ function truncateObjective(objective) {
   return objective.length > 80 ? `${objective.slice(0, 77).trimEnd()}...` : objective;
 }
 function seedDefaultSuccessCriteria(goalIndex, objective) {
-  const subject = truncateObjective(normalizeObjective4(objective) || `Goal ${goalIndex + 1}`);
+  const subject = truncateObjective(normalizeObjective2(objective) || `Goal ${goalIndex + 1}`);
   const rows = [
     [
       "C001",
@@ -2148,8 +2053,8 @@ function seedDefaultSuccessCriteria(goalIndex, objective) {
   }));
 }
 function deriveGoalCandidates(brief) {
-  const bulletGoals = brief.split(/\r?\n/).map((line) => ({ original: line, cleaned: normalizeObjective4(cleanLine(line)) })).filter(({ cleaned }) => cleaned.length > 0 && cleaned.length <= 1200).filter(({ original, cleaned }, index, all) => /^\s*(?:[-*+]\s+|\d+[.)]\s+)/.test(original) && all.findIndex((candidate) => candidate.cleaned === cleaned) === index).map(({ cleaned }) => cleaned);
-  const paragraphs = brief.split(/\n\s*\n/).map(normalizeObjective4).filter((paragraph) => paragraph.length > 0 && !paragraph.startsWith("#"));
+  const bulletGoals = brief.split(/\r?\n/).map((line) => ({ original: line, cleaned: normalizeObjective2(cleanLine(line)) })).filter(({ cleaned }) => cleaned.length > 0 && cleaned.length <= 1200).filter(({ original, cleaned }, index, all) => /^\s*(?:[-*+]\s+|\d+[.)]\s+)/.test(original) && all.findIndex((candidate) => candidate.cleaned === cleaned) === index).map(({ cleaned }) => cleaned);
+  const paragraphs = brief.split(/\n\s*\n/).map(normalizeObjective2).filter((paragraph) => paragraph.length > 0 && !paragraph.startsWith("#"));
   const selected = (bulletGoals.length > 0 ? bulletGoals : paragraphs).length > 0 ? bulletGoals.length > 0 ? bulletGoals : paragraphs : ["Complete the requested project objective."];
   return selected.map((objective, index) => ({
     title: titleFromObjective(objective, `Goal ${index + 1}`),
@@ -2195,7 +2100,7 @@ function clearGoalBlockerFields2(goal) {
 }
 async function createUlwLoopPlan(repoRoot, args, scope) {
   return withUlwLoopMutationLock(repoRoot, scope, async () => {
-    if (!args.force && existsSync5(ulwLoopGoalsPath(repoRoot, scope))) {
+    if (!args.force && existsSync4(ulwLoopGoalsPath(repoRoot, scope))) {
       const existing = await readUlwLoopPlan(repoRoot, scope);
       if (isUlwLoopDone(existing))
         throw completedPlanExistsError(scope);
@@ -2327,10 +2232,7 @@ async function checkpoint(repoRoot, argv, json, scope) {
   const goalId = required2(argv, "--goal-id");
   const statusValue = checkpointStatus(required2(argv, "--status"));
   const evidence = required2(argv, "--evidence");
-  const codexGoalJson = await parseCodexGoalJson(statusValue === "complete" ? required2(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 codexGoalJson = await parseCodexGoalJson(readValue(argv, "--codex-goal-json"));
   const qualityGateJson = readValue(argv, "--quality-gate-json");
   const args = {
     goalId,
@@ -2376,7 +2278,7 @@ function checkpointStatus(value) {
 }
 
 // components/ulw-loop/src/cli-subcommands.ts
-import { readFile as readFile6 } from "node:fs/promises";
+import { readFile as readFile5 } from "node:fs/promises";
 
 // components/ulw-loop/src/cli-steering.ts
 var SOURCES = ["user_prompt_submit", "finding", "cli"];
@@ -2723,11 +2625,12 @@ async function recordFinalReviewBlockers(repoRoot, args, scope) {
     if (!isFinalRunCompletionCandidate(plan, goal))
       ulwLoopError(`${goal.id} is not final.`, "ulw_loop_not_final_story");
     const snapshot = await readCodexGoalSnapshotInput(args.codexGoalJson, repoRoot);
-    const aggregate = codexGoalMode(plan) === "aggregate";
-    const expected = expectedCodexObjective(plan, goal);
-    const reconciliation = reconcileCodexGoalSnapshot(snapshot, { expectedObjective: expected, ...aggregate ? { acceptedObjectives: compatibleCodexObjectives(plan) } : {}, allowedStatuses: ["active"], requireSnapshot: true, requireComplete: false });
+    const reconciliation = reconcileCodexGoalSnapshot(snapshot, {
+      expectedObjective: expectedCodexObjective(plan, goal),
+      acceptedObjectives: compatibleCodexObjectives(plan)
+    });
     if (!reconciliation.ok)
-      throw codexSnapshotMismatchError({ reconciliation, snapshot, expectedObjective: expected });
+      throw new CodexGoalSnapshotError(formatCodexGoalReconciliation(reconciliation));
     const now = iso();
     for (const field of BLOCKER_FIELDS)
       Reflect.deleteProperty(goal, field);
@@ -2739,7 +2642,7 @@ async function recordFinalReviewBlockers(repoRoot, args, scope) {
       delete plan.activeGoalId;
     const newGoal = appendBlockerGoal(plan, args, now);
     plan.updatedAt = now;
-    const codexGoal = reconciliation.snapshot.raw;
+    const codexGoal = snapshot?.raw;
     const blockedEntry = { at: now, kind: "goal_review_blocked", goalId: goal.id, status: goal.status, evidence: args.evidence, codexGoal };
     const addedEntry = { at: now, kind: "goal_added", goalId: newGoal.id, status: newGoal.status, evidence: args.evidence, message: newGoal.title };
     const summaryEntry = { at: now, kind: "goal_review_blocked", goalId: goal.id, status: goal.status, evidence: args.evidence, codexGoal, message: `Review blockers recorded; appended ${newGoal.id}.` };
@@ -2748,7 +2651,14 @@ async function recordFinalReviewBlockers(repoRoot, args, scope) {
     await writePlan(repoRoot, plan, scope);
     for (const entry of ledgerEntries)
       await appendLedger(repoRoot, entry, scope);
-    return { plan, blockedGoal: goal, newGoal, ledgerEntries };
+    return {
+      plan,
+      blockedGoal: goal,
+      newGoal,
+      ledgerEntries,
+      nextActions: reconciliation.warnings,
+      warnings: reconciliation.warnings.filter((warning) => warning.startsWith("driver_objective_differs"))
+    };
   });
 }
 
@@ -3213,7 +3123,7 @@ function ledgerEntry2(proposal, audit, at) {
 // components/ulw-loop/src/cli-subcommands.ts
 async function createGoals(repoRoot, argv, json, scope) {
   const briefFile = readValue(argv, "--brief-file");
-  const brief = readValue(argv, "--brief") ?? (briefFile === undefined ? undefined : await readFile6(briefFile, "utf8")) ?? (hasFlag(argv, "--from-stdin") ? await readStdin() : undefined) ?? positionalText(argv);
+  const brief = readValue(argv, "--brief") ?? (briefFile === undefined ? undefined : await readFile5(briefFile, "utf8")) ?? (hasFlag(argv, "--from-stdin") ? await readStdin() : undefined) ?? positionalText(argv);
   if (!brief.trim()) {
     throw new UlwLoopError("Missing brief text. Pass --brief, --brief-file, --from-stdin, or positional text.", "ULW_LOOP_BRIEF_REQUIRED");
   }
@@ -3342,6 +3252,8 @@ async function reviewBlockers(repoRoot, argv, json, scope) {
       blockedGoal: result.blockedGoal,
       goal: result.newGoal,
       ledgerEntries: result.ledgerEntries,
+      nextActions: result.nextActions,
+      warnings: result.warnings,
       summary: summarizeUlwLoopPlan(result.plan)
     });
   } else {
@@ -3479,7 +3391,7 @@ function commandScope(repoRoot, argv) {
 import { readFileSync as readFileSync4 } from "node:fs";
 
 // components/ulw-loop/src/ultrawork-skill-pointer.ts
-import { existsSync as existsSync6, readFileSync as readFileSync3 } from "node:fs";
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "node:fs";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var ULTRAWORK_SKILL_POINTER_TEMPLATE = `<ultrawork-mode>
 ULTRAWORK MODE IS ACTIVE FOR THIS TASK.
@@ -3520,7 +3432,7 @@ function buildUltraworkSkillPointer(skillFilePath) {
 }
 function buildUltraworkAdditionalContext(options = {}) {
   const skillFilePath = options.skillFilePath === undefined ? resolveUltraworkSkillFilePath() : options.skillFilePath;
-  if (skillFilePath !== null && existsSync6(skillFilePath)) {
+  if (skillFilePath !== null && existsSync5(skillFilePath)) {
     return buildUltraworkSkillPointer(skillFilePath);
   }
   return ULTRAWORK_DIRECTIVE;
@@ -3768,7 +3680,7 @@ function readAll(stdin) {
 
 // components/ulw-loop/src/spawn-guard.ts
 import { randomBytes } from "node:crypto";
-import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync5, renameSync, statSync as statSync3, writeFileSync } from "node:fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync5, renameSync, statSync as statSync3, writeFileSync } from "node:fs";
 import { dirname as dirname3, join as join3 } from "node:path";
 var SPAWN_TOOL_TOKENS = new Set(["spawn_agent", "collaborationspawn_agent", "collaboration.spawn_agent"]);
 var DEFAULT_FANOUT_LIMIT = 24;
@@ -4002,7 +3914,7 @@ function reviewSpawnLimit() {
 }
 function isNonEmptyFile(path) {
   try {
-    return existsSync7(path) && statSync3(path).size > 0;
+    return existsSync6(path) && statSync3(path).size > 0;
   } catch (error) {
     if (error instanceof Error)
       return false;
@@ -4047,7 +3959,7 @@ function readPlan(goalsPath) {
 }
 
 // components/ulw-loop/src/stop-resume-hook.ts
-import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "node:fs";
 import { isAbsolute as isAbsolute2, join as join4, resolve as resolve4, sep as sep2 } from "node:path";
 var RESUME_CAP = 2;
 var CONTEXT_PRESSURE_MARKERS2 = [
@@ -4167,7 +4079,7 @@ function countLedgerLines(ledgerPath) {
 }
 function readCounter(counterPath) {
   try {
-    if (!existsSync8(counterPath))
+    if (!existsSync7(counterPath))
       return null;
     const parsed = JSON.parse(readFileSync6(counterPath, "utf8"));
     if (typeof parsed["count"] !== "number" || typeof parsed["ledgerLineCount"] !== "number")

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

@@ -1,4 +1,4 @@
-export type CodexGoalSnapshotStatus = "active" | "complete" | "cancelled" | "failed" | "unknown";
+export type CodexGoalSnapshotStatus = "active" | "complete" | "paused" | "usage_limited" | "budget_limited" | "cancelled" | "failed" | "unknown";
 export interface CodexGoalSnapshot {
     available: boolean;
     objective?: string;
@@ -13,10 +13,7 @@ export interface CodexGoalReconciliation {
 }
 export interface ReconcileCodexGoalOptions {
     expectedObjective: string;
-    acceptedObjectives?: readonly string[];
-    allowedStatuses?: readonly CodexGoalSnapshotStatus[];
-    requireSnapshot?: boolean;
-    requireComplete?: boolean;
+    readonly acceptedObjectives?: readonly string[];
 }
 export declare class CodexGoalSnapshotError extends Error {
 }
@@ -24,16 +21,3 @@ export declare function parseCodexGoalSnapshot(value: unknown): CodexGoalSnapsho
 export declare function readCodexGoalSnapshotInput(raw: string | undefined, cwd?: string): Promise<CodexGoalSnapshot | null>;
 export declare function reconcileCodexGoalSnapshot(snapshot: CodexGoalSnapshot | null | undefined, options: ReconcileCodexGoalOptions): CodexGoalReconciliation;
 export declare function formatCodexGoalReconciliation(reconciliation: CodexGoalReconciliation): string;
-export interface CodexGoalMismatchRecovery {
-    readonly message: string;
-    readonly details: {
-        readonly expectedObjective: string;
-        readonly receivedObjective: string;
-    };
-}
-/**
- * The reconciliation errors normalize whitespace for comparison, which makes the
- * quoted objective unusable as a copy source. Recovery therefore carries the
- * plan's `codexObjective` verbatim so the agent can paste it into `update_goal`.
- */
-export declare function codexGoalMismatchRecovery(expectedObjective: string, snapshot: CodexGoalSnapshot | null | undefined): CodexGoalMismatchRecovery;