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

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

@@ -1,42 +1,22 @@
-import { canReconcileActiveFinalTaskScopedAggregateSnapshot, canReconcileCompletedTaskScopedAggregateSnapshot, codexSnapshotMismatchError, } from "./checkpoint-reconciliation.js";
-import { readCodexGoalSnapshotInput, reconcileCodexGoalSnapshot } from "./codex-goal-snapshot.js";
-import { codexGoalMode, compatibleCodexObjectives, expectedCodexObjective, isFinalRunCompletionCandidate, } from "./goal-status.js";
+import { CodexGoalSnapshotError, formatCodexGoalReconciliation, readCodexGoalSnapshotInput, reconcileCodexGoalSnapshot, } from "./codex-goal-snapshot.js";
+import { codexGoalMode, compatibleCodexObjectives, expectedCodexObjective } from "./goal-status.js";
 import { UlwLoopError } from "./types.js";
-function normalizeObjective(value) {
-    return value.replace(/\s+/g, " ").trim();
-}
 export 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 &&
-        normalizeObjective(objective) !== normalizeObjective(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")),
+    };
 }
 export function combineCheckpointValidationErrors(codexError, gateError) {
     return new UlwLoopError(`${codexError.message}\n${gateError.message}`, "ULW_LOOP_QUALITY_GATE_INVALID", {

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

@@ -27,10 +27,7 @@ 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 codexGoalJson = await parseCodexGoalJson(readValue(argv, "--codex-goal-json"));
     const qualityGateJson = readValue(argv, "--quality-gate-json");
     const args = {
         goalId,

package/packages/omo-codex/plugin/components/ulw-loop/dist/checkpoint-reconciliation.d.ts

@@ -1,20 +1,2 @@
-import type { CodexGoalReconciliation, CodexGoalSnapshot } from "./codex-goal-snapshot.js";
-import { type UlwLoopScope } from "./paths.js";
-import type { UlwLoopItem, UlwLoopPlan } from "./types.js";
 import { UlwLoopError } from "./types.js";
-export interface CodexSnapshotMismatchInput {
-    readonly reconciliation: CodexGoalReconciliation;
-    readonly snapshot: CodexGoalSnapshot | null | undefined;
-    readonly expectedObjective: string;
-    /** Only the checkpoint path can fall back to task-scoped aggregate reconciliation, so only it asks for that hint. */
-    readonly taskScopedHint?: {
-        readonly goal: UlwLoopItem;
-        readonly aggregate: boolean;
-        readonly final: boolean;
-    };
-}
 export declare function combineCheckpointValidationErrors(codexError: UlwLoopError, gateError: UlwLoopError): UlwLoopError;
-export declare function codexSnapshotMismatchError(input: CodexSnapshotMismatchInput): UlwLoopError;
-export declare function canReconcileCompletedTaskScopedAggregateSnapshot(repoRoot: string, plan: UlwLoopPlan, goal: UlwLoopItem, snapshotObjective: string, evidence: string, scope?: UlwLoopScope): Promise<boolean>;
-export declare function canReconcileActiveFinalTaskScopedAggregateSnapshot(repoRoot: string, plan: UlwLoopPlan, goal: UlwLoopItem, snapshotObjective: string, evidence: string, scope?: UlwLoopScope): Promise<boolean>;
-export declare function buildTaskScopedAggregateReconciliationHint(goal: UlwLoopItem, final: boolean): string;

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

@@ -1,93 +1,6 @@
-import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { codexGoalMismatchRecovery, formatCodexGoalReconciliation } from "./codex-goal-snapshot.js";
-import { codexGoalMode, isFinalRunCompletionCandidate } from "./goal-status.js";
-import { ulwLoopBriefPath } from "./paths.js";
-import { ULW_LOOP_DIR, ULW_LOOP_GOALS, ULW_LOOP_LEDGER, UlwLoopError } from "./types.js";
+import { UlwLoopError } from "./types.js";
 export function combineCheckpointValidationErrors(codexError, gateError) {
     return new UlwLoopError(`${codexError.message}\n${gateError.message}`, "ULW_LOOP_QUALITY_GATE_INVALID", {
         details: { ...(codexError.details ?? {}), ...(gateError.details ?? {}) },
     });
 }
-export 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}\n${recovery.message}`, "ulw_loop_codex_snapshot_mismatch", { details: recovery.details });
-}
-function normalizeObjective(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 = normalizeObjective(snapshotObjective).toLowerCase();
-    if (textMentionsUlwLoopPlanArtifact(actual))
-        return true;
-    if (actual.length < 24 || !existsSync(ulwLoopBriefPath(repoRoot, scope)))
-        return false;
-    try {
-        const brief = normalizeObjective(await readFile(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;
-    }
-}
-export 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);
-}
-export 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(" ");
-}
-export 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)}`;
-}

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

@@ -12,5 +12,7 @@ export interface CheckpointUlwLoopResult {
     readonly goal: UlwLoopItem;
     readonly ledgerEntry: UlwLoopLedgerEntry;
     readonly aggregateCompletion?: UlwLoopAggregateCompletion;
+    readonly nextActions: readonly string[];
+    readonly warnings: readonly string[];
 }
 export declare function checkpointUlwLoop(repoRoot: string, args: CheckpointUlwLoopArgs, scope?: UlwLoopScope): Promise<CheckpointUlwLoopResult>;

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

@@ -110,6 +110,8 @@ export 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);
@@ -125,7 +127,7 @@ export async function checkpointUlwLoop(repoRoot, args, scope) {
                 requireAllCriteriaPass(goal);
             let codexValidationError;
             try {
-                codexGoal = await validateCheckpointCodexGoal({
+                const validation = await validateCheckpointCodexGoal({
                     repoRoot,
                     plan,
                     goal,
@@ -133,6 +135,9 @@ export 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))
@@ -179,6 +184,8 @@ export 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);
@@ -187,7 +194,7 @@ export async function checkpointUlwLoop(repoRoot, args, scope) {
         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 };
+            ? { plan, goal, ledgerEntry, nextActions, warnings }
+            : { plan, goal, ledgerEntry, aggregateCompletion, nextActions, warnings };
     });
 }

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

@@ -66,14 +66,14 @@ export async function readJsonInput(value) {
 export async function parseCodexGoalJson(value) {
     if (value === undefined)
         return undefined;
-    const raw = looksLikeJson(value) ? value : await readFile(value, "utf8");
     try {
+        const raw = looksLikeJson(value) ? value : await readFile(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) {

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

@@ -140,6 +140,8 @@ export 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),
         });
     }