oh-my-opencode 5.0.0-beta.33 → 5.0.0-beta.35

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

@@ -3,7 +3,7 @@
 // components/ulw-loop/src/checkpoint.ts
 import { existsSync as existsSync4, statSync } from "node:fs";
 import { readFile as readFile5 } from "node:fs/promises";
-import { resolve as resolve4 } from "node:path";
+import { resolve as resolve3 } from "node:path";
 
 // components/ulw-loop/src/checkpoint-reconciliation.ts
 import { existsSync as existsSync2 } from "node:fs";
@@ -379,6 +379,44 @@ function buildTaskScopedAggregateReconciliationHint(goal, final) {
   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 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 }
+  });
+}
+function combineCheckpointValidationErrors(codexError, gateError) {
+  return new UlwLoopError(`${codexError.message}
+${gateError.message}`, "ULW_LOOP_QUALITY_GATE_INVALID", {
+    details: { ...codexError.details ?? {}, ...gateError.details ?? {} }
+  });
+}
+
 // components/ulw-loop/src/plan-io.ts
 import { createReadStream, readdirSync } from "node:fs";
 import { appendFile, mkdir, readFile as readFile3, rename, writeFile } from "node:fs/promises";
@@ -634,111 +672,113 @@ function requireEssentialCriteriaPass(goal) {
   });
 }
 
-// components/ulw-loop/src/quality-gate-aggregate.ts
+// components/ulw-loop/src/quality-gate-artifacts.ts
 import { resolve as resolve2 } from "node:path";
 
 // components/ulw-loop/src/quality-gate-fields.ts
 var PLACEHOLDER_PATTERN = /^(?:<replace:[^>]+>|placeholder|todo|tbd|n\/a|stub)$/i;
+var activeCollector;
+function withQualityGateCollector(operation) {
+  const previous = activeCollector;
+  const collector = { defects: [], poisonedFields: new Set, poisonedArtifactKinds: new Set };
+  activeCollector = collector;
+  try {
+    const result = operation();
+    if (collector.defects.length === 0)
+      return result;
+    throwQualityGateDefects(collector.defects);
+  } finally {
+    activeCollector = previous;
+  }
+}
+function throwQualityGateDefects(defects) {
+  const uniqueDefects = [
+    ...new Map(defects.map((defect) => [`${defect.field}\x00${defect.message}`, defect])).values()
+  ];
+  const fields = uniqueDefects.slice(0, 25);
+  const truncated = uniqueDefects.length > fields.length;
+  const message = [
+    `Final quality gate has ${fields.length}${truncated ? "+" : ""} validation defects:`,
+    ...fields.map((item) => `- ${item.field}: ${item.message}`)
+  ].join(`
+`);
+  throw new UlwLoopError(message, "ULW_LOOP_QUALITY_GATE_INVALID", {
+    details: { field: fields[0]?.field, fields, ...truncated ? { truncated: true } : {} }
+  });
+}
 function invalid(message, field) {
-  throw new UlwLoopError(message, "ULW_LOOP_QUALITY_GATE_INVALID", { details: { field } });
+  if (activeCollector === undefined)
+    throw new UlwLoopError(message, "ULW_LOOP_QUALITY_GATE_INVALID", { details: { field } });
+  activeCollector.defects.push({ field, message });
+  activeCollector.poisonedFields.add(field);
+  return;
+}
+function isPoisoned(field) {
+  return activeCollector?.poisonedFields.has(field) ?? false;
+}
+function markPoisonedArtifactKind(id) {
+  activeCollector?.poisonedArtifactKinds.add(id);
+}
+function isPoisonedArtifactKind(id) {
+  return activeCollector?.poisonedArtifactKinds.has(id) ?? false;
 }
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function section(value, field) {
-  return isRecord(value) ? value : invalid(`Final quality gate is missing ${field} evidence.`, field);
+  if (isRecord(value))
+    return value;
+  invalid(`Final quality gate is missing ${field} evidence.`, field);
+  return {};
 }
 function textField(value, field) {
-  if (typeof value !== "string" || value.trim() === "")
+  if (typeof value !== "string" || value.trim() === "") {
     invalid(`Final quality gate requires non-empty ${field}.`, field);
+    return "";
+  }
   const trimmed = value.trim();
   if (PLACEHOLDER_PATTERN.test(trimmed))
     invalid(`Final quality gate rejects placeholder ${field}.`, field);
   return trimmed;
 }
 function numberField(value, field) {
-  return typeof value === "number" && Number.isFinite(value) ? value : invalid(`Final quality gate requires numeric ${field}.`, field);
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  invalid(`Final quality gate requires numeric ${field}.`, field);
+  return 0;
 }
 function stringArray(value, field) {
-  if (!Array.isArray(value) || value.length === 0)
-    return invalid(`Final quality gate requires ${field}.`, field);
+  if (!Array.isArray(value) || value.length === 0) {
+    invalid(`Final quality gate requires ${field}.`, field);
+    return [];
+  }
   return value.map((item) => textField(item, field));
 }
 function emptyBlockers(value, field) {
   if (Array.isArray(value) && value.length === 0)
     return [];
   invalid(`${field} must be empty.`, field);
+  return [];
 }
 function literal(value, expected, field) {
   if (value === expected)
     return expected;
   invalid(`${field} must be ${String(expected)}.`, field);
-}
-
-// components/ulw-loop/src/quality-gate-aggregate.ts
-var PLACEHOLDER = /^(?:<replace:[^>]+>|placeholder|todo|tbd|n\/a|stub)$/i;
-function add(defects, field, message) {
-  defects.push({ field, message });
-}
-function text(value, field, defects) {
-  if (typeof value !== "string" || value.trim() === "")
-    add(defects, field, `Final quality gate requires non-empty ${field}.`);
-  else if (PLACEHOLDER.test(value.trim()))
-    add(defects, field, `Final quality gate rejects placeholder ${field}.`);
-}
-function section2(value, field, defects) {
-  if (!isRecord(value)) {
-    add(defects, field, `Final quality gate is missing ${field} evidence.`);
-    return {};
-  }
-  return value;
-}
-function aggregateQualityGateDefects(input, opts) {
-  if (!isRecord(input))
-    return;
-  const defects = [];
-  const gate = input;
-  const manual = section2(gate["manualQa"], "manualQa", defects);
-  const review = section2(gate["gateReview"], "gateReview", defects);
-  text(manual["evidence"], "manualQa.evidence", defects);
-  text(review["evidence"], "gateReview.evidence", defects);
-  if (review["recommendation"] !== "APPROVE")
-    add(defects, "gateReview.recommendation", "gateReview.recommendation must be APPROVE.");
-  const artifacts = Array.isArray(manual["artifactRefs"]) ? manual["artifactRefs"] : [];
-  for (const [index, item] of artifacts.entries()) {
-    if (!isRecord(item))
-      continue;
-    const path = item["path"];
-    if (typeof path !== "string" || path.trim() === "")
-      continue;
-    if (opts?.repoRoot !== undefined && opts.fs !== undefined && !opts.fs.existsSync(resolve2(opts.repoRoot, path)))
-      add(defects, `manualQa.artifactRefs[${index}].path`, `manualQa.artifactRefs[${index}].path must point to an existing artifact.`);
-  }
-  if (defects.length === 0)
-    return;
-  const truncated = defects.length > 25;
-  const fields = defects.slice(0, 25).map(({ field, message: message2 }) => ({ field, message: message2 }));
-  const message = [
-    `Final quality gate has ${fields.length}${truncated ? "+" : ""} validation defects:`,
-    ...fields.map((item) => `- ${item.field}: ${item.message}`)
-  ].join(`
-`);
-  throw new UlwLoopError(message, "ULW_LOOP_QUALITY_GATE_INVALID", {
-    details: { field: fields[0]?.field, fields, ...truncated ? { truncated: true } : {} }
-  });
+  return expected;
 }
 
 // components/ulw-loop/src/quality-gate-artifacts.ts
-import { resolve as resolve3 } from "node:path";
 function surfaceField(value, field) {
   if (value === "cli" || value === "http" || value === "tmux" || value === "browser" || value === "gui" || value === "data")
     return value;
   invalid(`${field} must be a supported manual QA surface.`, field);
+  return "cli";
 }
 function kindField(value, field) {
   if (value === "cli-transcript" || value === "log" || value === "screenshot" || value === "image" || value === "http-dump" || value === "data-diff")
     return value;
   invalid(`${field} must be a supported artifact kind.`, field);
+  return "log";
 }
 function artifactCompatible(surface, kind) {
   switch (surface) {
@@ -754,21 +794,21 @@ function artifactCompatible(surface, kind) {
       return kind === "data-diff";
     default:
       invalid("manualQa.surfaceEvidence has an unsupported surface.", "manualQa.surfaceEvidence.surface");
+      return false;
   }
 }
 function checkFile(path, field, opts) {
-  if (opts?.repoRoot === undefined || opts.fs === undefined)
+  if (opts?.repoRoot === undefined || opts.fs === undefined || isPoisoned(field))
     return;
-  const absolute = resolve3(opts.repoRoot, path);
-  if (!opts.fs.existsSync(absolute))
+  const absolute = resolve2(opts.repoRoot, path);
+  if (!opts.fs.existsSync(absolute)) {
     invalid(`${field} must point to an existing artifact.`, field);
+    return;
+  }
   if (opts.fs.statSync(absolute).size <= 0)
     invalid(`${field} must point to a non-empty artifact.`, field);
-  if (opts.currentAttemptDir !== undefined && opts.repoRoot !== undefined) {
-    const attemptRoot = resolve3(opts.repoRoot, opts.currentAttemptDir);
-    if (!isWithinAttemptDir(absolute, attemptRoot))
-      invalid(`${field} (${path}) must point to an artifact from the current attempt (${opts.currentAttemptDir}).`, field);
-  }
+  if (opts.currentAttemptDir !== undefined && !isWithinAttemptDir(absolute, resolve2(opts.repoRoot, opts.currentAttemptDir)))
+    invalid(`${field} (${path}) must point to an artifact from the current attempt (${opts.currentAttemptDir}).`, field);
 }
 function artifactMap(refs) {
   const byId = new Map;
@@ -780,39 +820,56 @@ function artifactMap(refs) {
   return byId;
 }
 function parseArtifactRefs(value, opts) {
-  if (!Array.isArray(value) || value.length === 0)
+  if (!Array.isArray(value) || value.length === 0) {
     invalid("manualQa.artifactRefs must not be empty.", "manualQa.artifactRefs");
-  return value.map((item, index) => {
-    const ref = section(item, `manualQa.artifactRefs[${index}]`);
-    const path = textField(ref["path"], `manualQa.artifactRefs[${index}].path`);
-    checkFile(path, `manualQa.artifactRefs[${index}].path`, opts);
-    return {
-      id: textField(ref["id"], `manualQa.artifactRefs[${index}].id`),
-      kind: kindField(ref["kind"], `manualQa.artifactRefs[${index}].kind`),
-      description: textField(ref["description"], `manualQa.artifactRefs[${index}].description`),
-      path
-    };
+    return [];
+  }
+  return value.flatMap((item, index) => {
+    const prefix = `manualQa.artifactRefs[${index}]`;
+    const ref = section(item, prefix);
+    if (isPoisoned(prefix))
+      return [];
+    const pathField = `${prefix}.path`;
+    const idField = `${prefix}.id`;
+    const kindFieldName = `${prefix}.kind`;
+    const descriptionField = `${prefix}.description`;
+    const path = textField(ref["path"], pathField);
+    const id = textField(ref["id"], idField);
+    const kind = kindField(ref["kind"], kindFieldName);
+    if (isPoisoned(kindFieldName))
+      markPoisonedArtifactKind(id);
+    const description = textField(ref["description"], descriptionField);
+    checkFile(path, pathField, opts);
+    return [{ id, kind, description, path }];
   });
 }
 function referencedArtifacts(value, field, byId) {
-  return stringArray(value, field).map((id) => {
+  const ids = stringArray(value, field);
+  if (isPoisoned(field))
+    return [];
+  return ids.flatMap((id) => {
     const artifact = byId.get(id);
-    if (artifact === undefined)
+    if (artifact === undefined) {
       invalid(`${field} references unknown artifact ${id}.`, field);
-    return artifact;
+      return [];
+    }
+    return [artifact];
   });
 }
 
 // components/ulw-loop/src/quality-gate-verdicts.ts
 function passedVerdict(value, field) {
-  if (value === "not_applicable")
+  if (value === "not_applicable") {
     invalid(`${field} must not be not_applicable.`, field);
+    return "passed";
+  }
   return literal(value, "passed", field);
 }
 function codeQualityStatusField(value, field) {
   if (value === "CLEAR" || value === "WATCH")
     return value;
   invalid(`${field} must be CLEAR or WATCH.`, field);
+  return "CLEAR";
 }
 function adversarialVerdict(row, field) {
   const value = row["verdict"];
@@ -822,6 +879,7 @@ function adversarialVerdict(row, field) {
     return { verdict: "not_applicable", reason: textField(row["reason"], `${field}.reason`) };
   }
   invalid(`${field} must be passed or not_applicable with a reason.`, field);
+  return { verdict: "passed" };
 }
 
 // components/ulw-loop/src/surface.ts
@@ -841,10 +899,6 @@ var REVIEWER_ROLES_BY_SURFACE = {
   }
 };
 var GATE_REVIEWER_AGENT_NAMES = new Set(Object.values(REVIEWER_ROLES_BY_SURFACE).map((roles) => roles.gateReview));
-var REQUIRED_GATE_SECTIONS_BY_SURFACE = {
-  lazycodex: ["codeReview", "manualQa", "gateReview", "iteration", "criteriaCoverage"],
-  "omo-senpi": ["manualQa", "gateReview", "iteration", "criteriaCoverage"]
-};
 var GATE_SECTION_BY_ACCEPTOR = {
   lazycodex: {
     codeReview: [REVIEWER_ROLES_BY_SURFACE.lazycodex.codeReview],
@@ -930,6 +984,10 @@ function clearGoalBlockerFields(goal) {
 
 // components/ulw-loop/src/quality-gate.ts
 function reviewerRoleField(value, expected, field) {
+  if (typeof value !== "string" || value.trim() === "") {
+    textField(value, field);
+    return expected;
+  }
   const actual = textField(value, field);
   if (actual !== expected)
     invalid(`${field} must be ${expected}.`, field);
@@ -937,44 +995,51 @@ function reviewerRoleField(value, expected, field) {
 }
 function reviewerAcceptorField(value, surface, sectionName) {
   const field = `${sectionName}.by`;
-  const actual = textField(value, field);
   const accepted = GATE_SECTION_BY_ACCEPTOR[surface][sectionName];
+  if (typeof value !== "string" || value.trim() === "") {
+    textField(value, field);
+    return accepted?.[0] ?? "";
+  }
+  const actual = textField(value, field);
   if (accepted === undefined || !accepted.includes(actual))
     invalid(`${field} must be one of ${accepted?.join(", ") ?? "the configured reviewers"}.`, field);
   return actual;
 }
 function validateQualityGate(input, opts) {
+  return withQualityGateCollector(() => validateQualityGateUncollected(input, opts));
+}
+function validateQualityGateUncollected(input, opts) {
   const surface = opts?.reviewerSurface ?? "lazycodex";
-  aggregateQualityGateDefects(input, opts);
   const gate = section(input, "qualityGate");
-  const requiredSections = REQUIRED_GATE_SECTIONS_BY_SURFACE[surface];
-  for (const sectionName of requiredSections)
-    section(gate[sectionName], sectionName);
   if (surface === "omo-senpi" && gate["codeReview"] !== undefined)
     invalid("omo-senpi gate has no codeReview lane.", "codeReview");
   const manualQa = section(gate["manualQa"], "manualQa");
   const gateReview = section(gate["gateReview"], "gateReview");
   const iteration = section(gate["iteration"], "iteration");
   const coverage = section(gate["criteriaCoverage"], "criteriaCoverage");
+  const codeReview = surface === "lazycodex" ? section(gate["codeReview"], "codeReview") : {};
   const manualQaBy = reviewerAcceptorField(manualQa["by"], surface, "manualQa");
   const gateReviewBy = reviewerAcceptorField(gateReview["by"], surface, "gateReview");
+  const manualQaEvidence = textField(manualQa["evidence"], "manualQa.evidence");
+  const gateReviewEvidence = textField(gateReview["evidence"], "gateReview.evidence");
   if (surface === "lazycodex")
-    reviewerRoleField(section(gate["codeReview"], "codeReview")["by"], "lazycodex-code-reviewer", "codeReview.by");
+    reviewerRoleField(codeReview?.["by"], "lazycodex-code-reviewer", "codeReview.by");
   const totalCriteria = numberField(coverage["totalCriteria"], "criteriaCoverage.totalCriteria");
   const passCount = numberField(coverage["passCount"], "criteriaCoverage.passCount");
-  if (passCount < totalCriteria)
+  if (!isPoisoned("criteriaCoverage.passCount") && passCount < totalCriteria)
     invalid("criteriaCoverage.passCount must cover totalCriteria.", "criteriaCoverage.passCount");
   const artifactRefs = parseArtifactRefs(manualQa["artifactRefs"], opts);
   const byId = artifactMap(artifactRefs);
   const surfaceEvidence = parseSurfaceEvidence(manualQa["surfaceEvidence"], byId);
   const adversarialCases = parseAdversarialCases(manualQa["adversarialCases"], byId);
   const gateReportPath = textField(gateReview["reportPath"], "gateReview.reportPath");
-  checkFile(gateReportPath, "gateReview.reportPath", opts);
+  if (!isPoisoned("gateReview.reportPath"))
+    checkFile(gateReportPath, "gateReview.reportPath", opts);
   const common = {
     manualQa: {
       by: manualQaBy,
       status: literal(manualQa["status"], "passed", "manualQa.status"),
-      evidence: textField(manualQa["evidence"], "manualQa.evidence"),
+      evidence: manualQaEvidence,
       surfaceEvidence,
       adversarialCases,
       artifactRefs
@@ -983,7 +1048,7 @@ function validateQualityGate(input, opts) {
       by: gateReviewBy,
       recommendation: literal(gateReview["recommendation"], "APPROVE", "gateReview.recommendation"),
       reportPath: gateReportPath,
-      evidence: textField(gateReview["evidence"], "gateReview.evidence"),
+      evidence: gateReviewEvidence,
       blockers: emptyBlockers(gateReview["blockers"], "gateReview.blockers")
     },
     iteration: {
@@ -1003,7 +1068,6 @@ function validateQualityGate(input, opts) {
   };
   if (surface === "omo-senpi")
     return { surface, ...common };
-  const codeReview = section(gate["codeReview"], "codeReview");
   const codeReportPath = textField(codeReview["reportPath"], "codeReview.reportPath");
   checkFile(codeReportPath, "codeReview.reportPath", opts);
   return {
@@ -1020,13 +1084,19 @@ function validateQualityGate(input, opts) {
   };
 }
 function parseSurfaceEvidence(value, byId) {
-  if (!Array.isArray(value) || value.length === 0)
+  if (!Array.isArray(value) || value.length === 0) {
     invalid("manualQa.surfaceEvidence must not be empty.", "manualQa.surfaceEvidence");
-  return value.map((item, index) => {
+    return [];
+  }
+  return value.flatMap((item, index) => {
     const row = section(item, `manualQa.surfaceEvidence[${index}]`);
+    if (isPoisoned(`manualQa.surfaceEvidence[${index}]`))
+      return [];
     const surface = surfaceField(row["surface"], `manualQa.surfaceEvidence[${index}].surface`);
     const artifacts = referencedArtifacts(row["artifactRefs"], `manualQa.surfaceEvidence[${index}].artifactRefs`, byId);
     for (const artifact of artifacts) {
+      if (isPoisoned(`manualQa.surfaceEvidence[${index}].surface`) || isPoisonedArtifactKind(artifact.id))
+        continue;
       if (!artifactCompatible(surface, artifact.kind)) {
         invalid(`manualQa.surfaceEvidence ${surface} artifact ${artifact.kind} is incompatible.`, "manualQa.surfaceEvidence");
       }
@@ -1042,10 +1112,14 @@ function parseSurfaceEvidence(value, byId) {
   });
 }
 function parseAdversarialCases(value, byId) {
-  if (!Array.isArray(value) || value.length === 0)
+  if (!Array.isArray(value) || value.length === 0) {
     invalid("manualQa.adversarialCases must not be empty.", "manualQa.adversarialCases");
-  return value.map((item, index) => {
+    return [];
+  }
+  return value.flatMap((item, index) => {
     const row = section(item, `manualQa.adversarialCases[${index}]`);
+    if (isPoisoned(`manualQa.adversarialCases[${index}]`))
+      return [];
     const artifacts = referencedArtifacts(row["artifactRefs"], `manualQa.adversarialCases[${index}].artifactRefs`, byId);
     const verdictInfo = adversarialVerdict(row, `manualQa.adversarialCases[${index}]`);
     return {
@@ -1158,7 +1232,7 @@ function isObject(value) {
 function read(value, key) {
   return Object.entries(value).find(([name]) => name === key)?.[1];
 }
-function text2(value, key) {
+function text(value, key) {
   const candidate = read(value, key);
   return typeof candidate === "string" && candidate.trim().length > 0 ? candidate.trim() : undefined;
 }
@@ -1179,9 +1253,9 @@ async function parseValidationBatches(input, goals) {
 function batchFromObject(value) {
   if (!isObject(value))
     fail("validation batch entries must be objects.");
-  const batchId = text2(value, "batchId");
+  const batchId = text(value, "batchId");
   const memberIds = strings(value, "memberIds");
-  const finalGoalId = text2(value, "finalGoalId");
+  const finalGoalId = text(value, "finalGoalId");
   if (batchId === undefined)
     fail("validation batch requires batchId.");
   if (memberIds === undefined || memberIds.length < 2)
@@ -1274,9 +1348,6 @@ var QUALITY_GATE_FS = { existsSync: existsSync4, statSync };
 function ulwLoopFail2(message, code) {
   throw new UlwLoopError(message, code);
 }
-function normalizeObjective3(value) {
-  return value.replace(/\s+/g, " ").trim();
-}
 function nonEmptyEvidence2(value) {
   const trimmed = value.trim();
   return trimmed || ulwLoopFail2("Evidence must be a non-empty string.", "ulw_loop_evidence_required");
@@ -1295,7 +1366,7 @@ async function readJsonInput2(raw, repoRoot) {
     if (!(error instanceof SyntaxError))
       throw error;
   }
-  const path = resolve4(repoRoot, trimmed);
+  const path = resolve3(repoRoot, trimmed);
   if (!existsSync4(path))
     return ulwLoopFail2("Quality gate JSON is neither valid JSON nor a readable path.", "ulw_loop_json_input_invalid");
   try {
@@ -1380,23 +1451,20 @@ async function checkpointUlwLoop(repoRoot, args, scope) {
         requireEssentialCriteriaPass(goal);
       else
         requireAllCriteriaPass(goal);
-      const snapshot = await readCodexGoalSnapshotInput(args.codexGoalJson, repoRoot);
-      const reconciliation = reconcileCodexGoalSnapshot(snapshot, {
-        expectedObjective: expectedCodexObjective(plan, goal),
-        ...aggregate ? { acceptedObjectives: compatibleCodexObjectives(plan) } : {},
-        allowedStatuses: aggregate ? final ? ["complete"] : ["active"] : ["complete"],
-        requireSnapshot: true,
-        requireComplete: !aggregate || final
-      });
-      codexGoal = reconciliation.snapshot.raw;
-      if (!reconciliation.ok) {
-        const objective = snapshot?.objective;
-        const mismatchedTaskObjective = snapshot?.available === true && objective !== undefined && normalizeObjective3(objective) !== normalizeObjective3(expectedCodexObjective(plan, goal));
-        const completedTaskScoped = mismatchedTaskObjective && snapshot.status === "complete" && await canReconcileCompletedTaskScopedAggregateSnapshot(repoRoot, plan, goal, objective, evidence, scope);
-        const activeFinalTaskScoped = mismatchedTaskObjective && snapshot.status === "active" && await canReconcileActiveFinalTaskScopedAggregateSnapshot(repoRoot, plan, goal, objective, evidence, scope);
-        const taskScoped = completedTaskScoped || activeFinalTaskScoped;
-        if (!taskScoped)
-          throw codexSnapshotMismatchError({ reconciliation, snapshot, expectedObjective: expectedCodexObjective(plan, goal), taskScopedHint: { goal, aggregate, final } });
+      let codexValidationError;
+      try {
+        codexGoal = await validateCheckpointCodexGoal({
+          repoRoot,
+          plan,
+          goal,
+          raw: args.codexGoalJson,
+          evidence,
+          ...scope === undefined ? {} : { scope }
+        });
+      } catch (error) {
+        if (!(error instanceof UlwLoopError))
+          throw error;
+        codexValidationError = error;
       }
       if (closesBatch)
         requireBatchFinalReady(plan, goal);
@@ -1405,14 +1473,22 @@ async function checkpointUlwLoop(repoRoot, args, scope) {
       if (final)
         aggregateCompletion = makeAggregateCompletion(now, evidence, codexGoal);
       if (final || aggregateCompletion !== undefined || closesBatch) {
-        qualityGate = validateQualityGate(await readJsonInput2(args.qualityGateJson, repoRoot), {
-          repoRoot,
-          fs: QUALITY_GATE_FS,
-          reviewerSurface: resolveToolkitSurface(),
-          ...plan.evidenceLayoutVersion === 2 ? { currentAttemptDir: ulwLoopAttemptEvidenceDir(goal.id, goal.attempt, scope) } : {}
-        });
-        requireBatchGate(plan, goal, qualityGate);
+        try {
+          qualityGate = validateQualityGate(await readJsonInput2(args.qualityGateJson, repoRoot), {
+            repoRoot,
+            fs: QUALITY_GATE_FS,
+            reviewerSurface: resolveToolkitSurface(),
+            ...plan.evidenceLayoutVersion === 2 ? { currentAttemptDir: ulwLoopAttemptEvidenceDir(goal.id, goal.attempt, scope) } : {}
+          });
+          requireBatchGate(plan, goal, qualityGate);
+        } catch (error) {
+          if (!(error instanceof UlwLoopError) || codexValidationError === undefined)
+            throw error;
+          throw combineCheckpointValidationErrors(codexValidationError, error);
+        }
       }
+      if (codexValidationError !== undefined)
+        throw codexValidationError;
       goal.status = "complete";
       goal.completedAt = now;
       goal.evidence = evidence;
@@ -1498,7 +1574,8 @@ function gateTemplate(surface, base) {
       recommendation: "APPROVE",
       reportPath: artifactPath(base, "gate-review.md"),
       evidence: "<replace:gate review evidence>",
-      blockers: []
+      blockers: [],
+      notes: []
     },
     iteration: {
       fullRerun: true,
@@ -1537,12 +1614,20 @@ async function checkpointTemplate(repoRoot, scope, goalId) {
     throw new UlwLoopError(`Unknown ulw-loop id: ${goalId}.`, "ULW_LOOP_GOAL_NOT_FOUND", { details: { goalId } });
   const hasAttempt = plan.evidenceLayoutVersion === 2 && active !== undefined;
   const attemptDir = hasAttempt ? ulwLoopAttemptEvidenceDir(active.id, active.attempt, scope) : ".omo/evidence";
+  const guidance = [
+    "codex-goal-json requires goal.objective to equal the plan's codexObjective verbatim; do not paraphrase it.",
+    "Fill every <replace:...> value with plausible non-empty evidence and use real, non-empty artifact files.",
+    'Passing codex-goal-json example: {"goal":{"objective":"<plan codexObjective verbatim>","status":"complete"}}.',
+    'Passing quality-gate-json example requires gateReview {"by":"category:deep","recommendation":"APPROVE","evidence":"review passed","reportPath":"<attemptDir>/gate-review.md","blockers":[],"notes":[]}, manualQa.artifactRefs objects, iteration, and criteriaCoverage.',
+    ...hasAttempt ? [] : ["This plan is evidence-layout v1; artifacts go under .omo/evidence/."]
+  ].join(" ");
   return {
     qualityGateTemplate: gateTemplate(resolveToolkitSurface(), attemptDir),
     codexGoalTemplate: {
       goal: { objective: plan.codexObjective ?? "<replace:codex objective>", status: "complete" }
     },
-    ...hasAttempt ? { attemptDir } : { guidance: "This plan is evidence-layout v1; artifacts go under .omo/evidence/." }
+    guidance,
+    ...hasAttempt ? { attemptDir } : {}
   };
 }
 
@@ -2094,7 +2179,7 @@ function kindMessage(prefix) {
 
 ${STEERING_KIND_HELP}`;
 }
-function text3(value, field) {
+function text2(value, field) {
   if (value === undefined)
     return;
   const trimmed = value.trim();
@@ -2103,11 +2188,11 @@ function text3(value, field) {
   return fail2(`Empty ${field}.`, "ULW_LOOP_STEERING_FIELD_EMPTY", { field });
 }
 function required3(argv, flag) {
-  const value = text3(readValue(argv, flag), flag);
+  const value = text2(readValue(argv, flag), flag);
   return value ?? fail2(`Missing ${flag}.`, "ULW_LOOP_STEERING_FIELD_REQUIRED", { flag });
 }
 function requiredGoal(argv) {
-  const value = text3(parseGoalArg(argv), "--goal-id");
+  const value = text2(parseGoalArg(argv), "--goal-id");
   return value ?? fail2("Missing --goal-id.", "ULW_LOOP_GOAL_ID_REQUIRED", { flag: "--goal-id" });
 }
 function readObject(value, key) {
@@ -2158,14 +2243,14 @@ function parseSteeringSource(argv) {
 function child(value) {
   if (!isPlain(value))
     return null;
-  const title = text3(objectText(value, "title"), "title");
-  const objective = text3(objectText(value, "objective"), "objective");
+  const title = text2(objectText(value, "title"), "title");
+  const objective = text2(objectText(value, "objective"), "objective");
   if (title === undefined || objective === undefined)
     return null;
   return { title, objective };
 }
 async function children(argv, flag, needed) {
-  const input = needed ? required3(argv, flag) : text3(readValue(argv, flag), flag);
+  const input = needed ? required3(argv, flag) : text2(readValue(argv, flag), flag);
   if (input === undefined)
     return [];
   const raw = await readJsonInput(input);
@@ -2188,12 +2273,12 @@ async function stringArray2(argv, flag) {
   for (const item of raw) {
     if (typeof item !== "string")
       return fail2(`${flag} entries must be strings.`, "ULW_LOOP_STEERING_STRING_ARRAY_REQUIRED", { flag });
-    values.push(text3(item, flag) ?? "");
+    values.push(text2(item, flag) ?? "");
   }
   return values;
 }
 function model(value) {
-  const trimmed = text3(value, "--user-model");
+  const trimmed = text2(value, "--user-model");
   if (trimmed === undefined)
     return;
   return isModel(trimmed) ? trimmed : fail2(`Invalid --user-model: ${trimmed}.`, "ULW_LOOP_STEERING_USER_MODEL_INVALID", { value: trimmed, expected: ULW_LOOP_SUCCESS_CRITERION_USER_MODELS });
@@ -2204,7 +2289,7 @@ function neverKind(kind) {
 async function parseSteeringProposal(argv) {
   const kind = parseSteeringKind(argv);
   const source = parseSteeringSource(argv);
-  const idempotencyKey = text3(readValue(argv, "--idempotency-key"), "--idempotency-key");
+  const idempotencyKey = text2(readValue(argv, "--idempotency-key"), "--idempotency-key");
   const base = { kind, source, evidence: required3(argv, "--evidence"), rationale: required3(argv, "--rationale"), ...idempotencyKey === undefined ? {} : { idempotencyKey } };
   switch (kind) {
     case "add_subgoal":
@@ -2247,36 +2332,36 @@ async function parseSteeringProposal(argv) {
 function normalizedChildren(values) {
   if (values === undefined)
     return;
-  return values.map((item) => ({ title: text3(item.title, "child.title") ?? "", objective: text3(item.objective, "child.objective") ?? "" }));
+  return values.map((item) => ({ title: text2(item.title, "child.title") ?? "", objective: text2(item.objective, "child.objective") ?? "" }));
 }
 function normalizedStrings(values, field) {
   if (values === undefined)
     return;
-  return values.map((value) => text3(value, field) ?? "");
+  return values.map((value) => text2(value, field) ?? "");
 }
 function normalizeSteeringProposal(proposal) {
-  const evidence = text3(proposal.evidence, "evidence") ?? "";
-  const rationale = text3(proposal.rationale, "rationale") ?? "";
-  const goalId = text3(proposal.goalId, "goalId");
-  const targetGoalId = text3(proposal.targetGoalId, "targetGoalId");
+  const evidence = text2(proposal.evidence, "evidence") ?? "";
+  const rationale = text2(proposal.rationale, "rationale") ?? "";
+  const goalId = text2(proposal.goalId, "goalId");
+  const targetGoalId = text2(proposal.targetGoalId, "targetGoalId");
   const targetGoalIds = normalizedStrings(proposal.targetGoalIds, "targetGoalIds");
-  const criterionId = text3(proposal.criterionId, "criterionId");
-  const title = text3(proposal.title, "title");
-  const objective = text3(proposal.objective, "objective");
-  const revisedTitle = text3(proposal.revisedTitle, "revisedTitle");
-  const revisedObjective = text3(proposal.revisedObjective, "revisedObjective");
-  const blockedReason = text3(proposal.blockedReason, "blockedReason");
-  const directiveText = text3(proposal.directiveText, "directiveText");
-  const promptSignature = text3(proposal.promptSignature, "promptSignature");
-  const idempotencyKey = text3(proposal.idempotencyKey, "idempotencyKey");
-  const scenario = text3(proposal.scenario, "scenario");
-  const expectedEvidence = text3(proposal.expectedEvidence, "expectedEvidence");
+  const criterionId = text2(proposal.criterionId, "criterionId");
+  const title = text2(proposal.title, "title");
+  const objective = text2(proposal.objective, "objective");
+  const revisedTitle = text2(proposal.revisedTitle, "revisedTitle");
+  const revisedObjective = text2(proposal.revisedObjective, "revisedObjective");
+  const blockedReason = text2(proposal.blockedReason, "blockedReason");
+  const directiveText = text2(proposal.directiveText, "directiveText");
+  const promptSignature = text2(proposal.promptSignature, "promptSignature");
+  const idempotencyKey = text2(proposal.idempotencyKey, "idempotencyKey");
+  const scenario = text2(proposal.scenario, "scenario");
+  const expectedEvidence = text2(proposal.expectedEvidence, "expectedEvidence");
   const childGoals = normalizedChildren(proposal.childGoals);
   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 } };
 }
 async function parseSteeringProposals(argv) {
-  const input = text3(readValue(argv, "--proposals-json"), "--proposals-json");
+  const input = text2(readValue(argv, "--proposals-json"), "--proposals-json");
   if (input === undefined)
     return [await parseSteeringProposal(argv)];
   if (readValue(argv, "--kind") !== undefined)
@@ -2468,7 +2553,7 @@ function activeGoalActions(plan, active) {
 // components/ulw-loop/src/steering-mutations.ts
 var read2 = (value, key) => Object.entries(value).find(([name]) => name === key)?.[1];
 var isText = (value) => typeof value === "string" && value.trim().length > 0;
-var text4 = (value, key) => {
+var text3 = (value, key) => {
   const candidate = read2(value, key);
   return isText(candidate) ? candidate.trim() : undefined;
 };
@@ -2477,13 +2562,13 @@ var after = (proposal) => {
   const candidate = read2(proposal, "after");
   return typeof candidate === "object" && candidate !== null && !Array.isArray(candidate) ? candidate : undefined;
 };
-var revised = (proposal, direct, nested) => text4(proposal, direct) ?? text4(after(proposal) ?? proposal, nested);
-var targets = (proposal) => proposal.targetGoalIds ?? [proposal.targetGoalId ?? text4(proposal, "goalId") ?? ""].filter(Boolean);
+var revised = (proposal, direct, nested) => text3(proposal, direct) ?? text3(after(proposal) ?? proposal, nested);
+var targets = (proposal) => proposal.targetGoalIds ?? [proposal.targetGoalId ?? text3(proposal, "goalId") ?? ""].filter(Boolean);
 var child2 = (value) => {
   if (typeof value !== "object" || value === null || Array.isArray(value))
     return null;
-  const title = text4(value, "title");
-  const objective = text4(value, "objective");
+  const title = text3(value, "title");
+  const objective = text3(value, "objective");
   return title === undefined || objective === undefined ? null : { title, objective };
 };
 var children2 = (proposal) => {
@@ -2548,7 +2633,7 @@ function reviseCriterion(plan, proposal, now) {
   if (target === undefined || current === undefined)
     return;
   const model2 = read2(proposal, "userModel");
-  target.successCriteria[index] = { ...current, scenario: text4(proposal, "scenario") ?? current.scenario, expectedEvidence: text4(proposal, "expectedEvidence") ?? current.expectedEvidence, userModel: isModel2(model2) ? model2 : current.userModel };
+  target.successCriteria[index] = { ...current, scenario: text3(proposal, "scenario") ?? current.scenario, expectedEvidence: text3(proposal, "expectedEvidence") ?? current.expectedEvidence, userModel: isModel2(model2) ? model2 : current.userModel };
   target.updatedAt = now;
 }
 
@@ -2583,7 +2668,7 @@ var isObject2 = (value) => typeof value === "object" && value !== null;
 var isPlain2 = (value) => isObject2(value) && !Array.isArray(value);
 var read3 = (value, key) => Object.entries(value).find(([name]) => name === key)?.[1];
 var isText2 = (value) => typeof value === "string" && value.trim().length > 0;
-var text5 = (value, key) => {
+var text4 = (value, key) => {
   const candidate = read3(value, key);
   return isText2(candidate) ? candidate.trim() : undefined;
 };
@@ -2596,19 +2681,19 @@ var texts = (value, key) => {
 };
 function targets2(proposal) {
   const many = texts(proposal, "targetGoalIds");
-  const one = text5(proposal, "targetGoalId") ?? text5(proposal, "goalId");
+  const one = text4(proposal, "targetGoalId") ?? text4(proposal, "goalId");
   return many.length > 0 ? many : one === undefined ? [] : [one];
 }
 var after2 = (proposal) => {
   const candidate = read3(proposal, "after");
   return isPlain2(candidate) ? candidate : undefined;
 };
-var revised2 = (proposal, direct, nested) => text5(proposal, direct) ?? text5(after2(proposal) ?? proposal, nested);
+var revised2 = (proposal, direct, nested) => text4(proposal, direct) ?? text4(after2(proposal) ?? proposal, nested);
 function child3(value) {
   if (!isPlain2(value))
     return null;
-  const title = text5(value, "title");
-  const objective = text5(value, "objective");
+  const title = text4(value, "title");
+  const objective = text4(value, "objective");
   if (title === undefined || objective === undefined)
     return null;
   return { title, objective };
@@ -2647,15 +2732,15 @@ function auditFor(proposal, reasons) {
   const object = isPlain2(proposal) ? proposal : undefined;
   const kindRaw = object === undefined ? undefined : read3(object, "kind");
   const sourceRaw = object === undefined ? undefined : read3(object, "source");
-  const evidence = object === undefined ? "" : text5(object, "evidence") ?? "";
-  const rationale = object === undefined ? "" : text5(object, "rationale") ?? "";
+  const evidence = object === undefined ? "" : text4(object, "evidence") ?? "";
+  const rationale = object === undefined ? "" : text4(object, "rationale") ?? "";
   const audit = { kind: isKind2(kindRaw) ? kindRaw : "annotate_ledger", source: isSource2(sourceRaw) ? sourceRaw : "cli", targetGoalIds: object === undefined ? [] : targets2(object), evidence, rationale, invariant: { accepted: reasons.length === 0, structuralInvariantAccepted: reasons.length === 0, evidenceBackedNecessity: evidence.length > 0 && rationale.length > 0, noEasierCompletion: !weakens(proposal), rejectedReasons: reasons, reasons } };
   if (object === undefined)
     return audit;
-  const criterionId = text5(object, "criterionId");
-  const directiveText = text5(object, "directiveText");
-  const promptSignature = text5(object, "promptSignature");
-  const idempotencyKey = text5(object, "idempotencyKey");
+  const criterionId = text4(object, "criterionId");
+  const directiveText = text4(object, "directiveText");
+  const promptSignature = text4(object, "promptSignature");
+  const idempotencyKey = text4(object, "idempotencyKey");
   if (criterionId !== undefined)
     audit.criterionId = criterionId;
   if (directiveText !== undefined)
@@ -2676,9 +2761,9 @@ function validateUlwLoopSteeringProposal(plan, proposal) {
     reasons.push(`invalid kind: ${String(kind)}`);
   if (!isSource2(read3(object, "source")))
     reasons.push(`invalid source: ${String(read3(object, "source"))}`);
-  if (text5(object, "evidence") === undefined)
+  if (text4(object, "evidence") === undefined)
     reasons.push("missing evidence");
-  if (text5(object, "rationale") === undefined)
+  if (text4(object, "rationale") === undefined)
     reasons.push("missing rationale");
   if (hasProtected(proposal))
     reasons.push("protected payload");
@@ -2695,7 +2780,7 @@ function goal2(plan, id) {
 }
 function validateKind(plan, proposal, kind, reasons) {
   const target = goal2(plan, targets2(proposal)[0]);
-  if (kind === "add_subgoal" && (text5(proposal, "title") === undefined || text5(proposal, "objective") === undefined))
+  if (kind === "add_subgoal" && (text4(proposal, "title") === undefined || text4(proposal, "objective") === undefined))
     reasons.push("add_subgoal requires title/objective");
   if ((kind === "split_subgoal" || kind === "revise_pending_wording" || kind === "mark_blocked_superseded") && target === undefined)
     reasons.push(`${kind} requires target`);
@@ -2725,7 +2810,7 @@ function validateOrder(plan, proposal, reasons) {
 }
 function validateCriterion(plan, proposal, reasons) {
   const target = goal2(plan, targets2(proposal)[0]);
-  const criterionId = text5(proposal, "criterionId");
+  const criterionId = text4(proposal, "criterionId");
   if (target === undefined)
     reasons.push("revise_criterion requires goalId");
   else if (criterionId === undefined || target.successCriteria.every((item) => item.id !== criterionId))
@@ -2760,8 +2845,8 @@ function applySteeringMutation(plan, proposal, audit) {
 function isProposal(value) {
   return isPlain2(value) && isKind2(read3(value, "kind")) && isSource2(read3(value, "source")) && isText2(read3(value, "evidence")) && isText2(read3(value, "rationale"));
 }
-function parseUlwLoopSteeringDirective(text6) {
-  const match = /(?:^|\s)(?:OMO_ULW_LOOP_STEER|omo\.ulw-loop\.steer|omo ulw-loop steer|omo-agent-toolkit ulw-loop steer):\s*([\s\S]+)$/u.exec(text6);
+function parseUlwLoopSteeringDirective(text5) {
+  const match = /(?:^|\s)(?:OMO_ULW_LOOP_STEER|omo\.ulw-loop\.steer|omo ulw-loop steer|omo-agent-toolkit ulw-loop steer):\s*([\s\S]+)$/u.exec(text5);
   if (match?.[1] === undefined)
     return null;
   try {
@@ -3435,14 +3520,14 @@ function optionalString(value) {
   return value === undefined || typeof value === "string";
 }
 function readAll(stdin) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve4, reject) => {
     let data = "";
     stdin.setEncoding("utf8");
     stdin.on("data", (chunk) => {
       data += chunk instanceof Buffer ? chunk.toString() : String(chunk);
     });
     stdin.once("error", reject);
-    stdin.once("end", () => resolve5(data));
+    stdin.once("end", () => resolve4(data));
   });
 }
 
@@ -3740,7 +3825,7 @@ function readPlan(goalsPath) {
 
 // components/ulw-loop/src/stop-resume-hook.ts
 import { existsSync as existsSync8, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "node:fs";
-import { isAbsolute as isAbsolute2, join as join4, resolve as resolve5, sep as sep2 } from "node:path";
+import { isAbsolute as isAbsolute2, join as join4, resolve as resolve4, sep as sep2 } from "node:path";
 var RESUME_CAP = 2;
 var CONTEXT_PRESSURE_MARKERS2 = [
   "context compacted",
@@ -3798,8 +3883,8 @@ function isResumableStatus(status2) {
 }
 function consumeResumeBudget(stateDir, goalId) {
   const ledgerLineCount = countLedgerLines(join4(stateDir, "ledger.jsonl"));
-  const counterPath = resolve5(stateDir, `auto-resume-${goalId}.json`);
-  const stuckPath = resolve5(stateDir, `auto-resume-${goalId}.stuck`);
+  const counterPath = resolve4(stateDir, `auto-resume-${goalId}.json`);
+  const stuckPath = resolve4(stateDir, `auto-resume-${goalId}.stuck`);
   if (!isInsideDir(stateDir, counterPath) || !isInsideDir(stateDir, stuckPath))
     return false;
   const previous = readCounter(counterPath);
@@ -3813,7 +3898,7 @@ function consumeResumeBudget(stateDir, goalId) {
   return true;
 }
 function isInsideDir(dir, candidate) {
-  return candidate.startsWith(resolve5(dir) + sep2);
+  return candidate.startsWith(resolve4(dir) + sep2);
 }
 function renderResumeDirective(plan, goal3, sessionId) {
   const normalized = normalizeUlwLoopSessionId(sessionId);