oh-my-opencode 4.10.0 → 4.11.0

package/packages/omo-codex/plugin/components/ultrawork/test/codex-hook.test.ts

@@ -1,16 +1,16 @@
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import path from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
 
-import { isUltraworkPrompt, runUserPromptSubmitHook } from "../src/codex-hook.js";
-
-const tempDirectories: string[] = [];
+import { runUserPromptSubmitHook } from "../src/codex-hook.js";
+import {
+	cleanupTempDirectories,
+	parseHookOutput,
+	writeCodexContextWindowTranscript,
+	writeContextPressureTranscript,
+	writeTranscript,
+} from "./codex-hook-test-helpers.js";
 
 afterEach(() => {
-	for (const directory of tempDirectories.splice(0)) {
-		rmSync(directory, { recursive: true, force: true });
-	}
+	cleanupTempDirectories();
 });
 
 describe("codex ultrawork hook", () => {
@@ -18,7 +18,7 @@ describe("codex ultrawork hook", () => {
 		// given
 		const payload = {
 			hook_event_name: "UserPromptSubmit",
-			prompt: "please ulw this change",
+			prompt: "ulw this change",
 		};
 
 		// when
@@ -38,7 +38,7 @@ describe("codex ultrawork hook", () => {
 			hook_event_name: "UserPromptSubmit",
 			model: "gpt-5.5",
 			permission_mode: "default",
-			prompt: "please ulw this change",
+			prompt: "ulw this change",
 			session_id: "s",
 			transcript_path: null,
 			turn_id: "t",
@@ -57,7 +57,7 @@ describe("codex ultrawork hook", () => {
 		// given
 		const payload = {
 			hook_event_name: "UserPromptSubmit",
-			prompt: "please ulw this change",
+			prompt: "ulw this change",
 			transcript_path: writeTranscript(
 				JSON.stringify({
 					hookSpecificOutput: {
@@ -75,11 +75,11 @@ describe("codex ultrawork hook", () => {
 		expect(output).toBe("");
 	});
 
-	it("#given transcript only mentions ultrawork marker in user content #when hook sees first ultrawork prompt #then it emits directive", () => {
+	it("#given transcript only mentions ultrawork marker in user content #when hook sees first ulw command #then it emits directive", () => {
 		// given
 		const payload = {
 			hook_event_name: "UserPromptSubmit",
-			prompt: "please ulw this change",
+			prompt: "ulw this change",
 			transcript_path: writeTranscript(
 				JSON.stringify({
 					role: "user",
@@ -96,21 +96,6 @@ describe("codex ultrawork hook", () => {
 		expect(parsed.hookSpecificOutput.additionalContext).toMatch(/^<ultrawork-mode>/);
 	});
 
-	it("#given identifier-like ulw #when hook runs #then does not emit directive", () => {
-		// given
-		const payload = {
-			hook_event_name: "UserPromptSubmit",
-			prompt: "refactor ulw_helper.ts",
-		};
-
-		// when
-		const output = runUserPromptSubmitHook(payload);
-
-		// then
-		expect(output).toBe("");
-		expect(isUltraworkPrompt("ulw_helper.ts")).toBe(false);
-	});
-
 	it("#given context-pressure recovery prompt with ulw #when hook runs #then does not add more context", () => {
 		// given
 		const payload = {
@@ -135,7 +120,7 @@ describe("codex ultrawork hook", () => {
 		// given
 		const payload = {
 			hook_event_name: "UserPromptSubmit",
-			prompt: "please ulw this change",
+			prompt: "ulw this change",
 			transcript_path: writeContextPressureTranscript(),
 		};
 
@@ -150,7 +135,7 @@ describe("codex ultrawork hook", () => {
 		// given
 		const payload = {
 			hook_event_name: "UserPromptSubmit",
-			prompt: "please ulw this change",
+			prompt: "ulw this change",
 			transcript_path: writeCodexContextWindowTranscript(),
 		};
 
@@ -194,7 +179,7 @@ describe("codex ultrawork hook", () => {
 		// given
 		const payload = {
 			hook_event_name: "UserPromptSubmit",
-			prompt: "please ultrawork",
+			prompt: "ulw",
 		};
 
 		// when
@@ -220,7 +205,7 @@ describe("codex ultrawork hook", () => {
 		// given
 		const payload = {
 			hook_event_name: "UserPromptSubmit",
-			prompt: "please ultrawork",
+			prompt: "ulw",
 		};
 
 		// when
@@ -241,7 +226,7 @@ describe("codex ultrawork hook", () => {
 		// given
 		const payload = {
 			hook_event_name: "UserPromptSubmit",
-			prompt: "please ultrawork",
+			prompt: "ulw",
 		};
 
 		// when
@@ -263,7 +248,7 @@ describe("codex ultrawork hook", () => {
 		// given
 		const payload = {
 			hook_event_name: "UserPromptSubmit",
-			prompt: "please ultrawork",
+			prompt: "ulw",
 		};
 
 		// when
@@ -272,99 +257,10 @@ describe("codex ultrawork hook", () => {
 
 		// then
 		const directive = parsed.hookSpecificOutput.additionalContext;
-		expect(directive).toMatch(/\bXS\b/);
-		expect(directive).toMatch(/ratchet UP/i);
-		expect(directive).toMatch(/PROOF RULE/);
+		expect(directive).toMatch(/# Tier triage/);
+		expect(directive).toMatch(/Default is LIGHT/);
+		expect(directive).toMatch(/Take HEAVY/);
+		expect(directive).toMatch(/ratchet up only/i);
 		expect(directive).toMatch(/`plan` agent/);
 	});
 });
-
-interface UserPromptSubmitHookOutput {
-	readonly hookSpecificOutput: {
-		readonly hookEventName: "UserPromptSubmit";
-		readonly additionalContext: string;
-	};
-}
-
-function parseHookOutput(output: string): UserPromptSubmitHookOutput {
-	const parsed: unknown = JSON.parse(output);
-	if (!isUserPromptSubmitHookOutput(parsed)) throw new TypeError("Expected UserPromptSubmit hook output");
-	return parsed;
-}
-
-function isUserPromptSubmitHookOutput(value: unknown): value is UserPromptSubmitHookOutput {
-	if (!isRecord(value)) return false;
-	const hookSpecificOutput = value["hookSpecificOutput"];
-	return (
-		isRecord(hookSpecificOutput) &&
-		hookSpecificOutput["hookEventName"] === "UserPromptSubmit" &&
-		typeof hookSpecificOutput["additionalContext"] === "string"
-	);
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function writeContextPressureTranscript(): string {
-	const root = mkdtempSync(path.join(tmpdir(), "codex-ultrawork-context-pressure-"));
-	tempDirectories.push(root);
-	const transcriptPath = path.join(root, "transcript.jsonl");
-	writeFileSync(
-		transcriptPath,
-		[
-			JSON.stringify({
-				type: "message",
-				payload: {
-					content: "Context compacted",
-				},
-			}),
-			JSON.stringify({
-				type: "message",
-				payload: {
-					content: "Your input exceeds the context window of this model.",
-				},
-			}),
-			"",
-		].join("\n"),
-	);
-	return transcriptPath;
-}
-
-function writeTranscript(...lines: string[]): string {
-	const root = mkdtempSync(path.join(tmpdir(), "codex-ultrawork-transcript-"));
-	tempDirectories.push(root);
-	const transcriptPath = path.join(root, "transcript.jsonl");
-	writeFileSync(transcriptPath, `${lines.join("\n")}\n`);
-	return transcriptPath;
-}
-
-function writeCodexContextWindowTranscript(): string {
-	const root = mkdtempSync(path.join(tmpdir(), "codex-ultrawork-context-window-"));
-	tempDirectories.push(root);
-	const transcriptPath = path.join(root, "transcript.jsonl");
-	writeFileSync(
-		transcriptPath,
-		[
-			JSON.stringify({
-				type: "message",
-				payload: {
-					content: {
-						error: {
-							code: "context_length_exceeded",
-						},
-					},
-				},
-			}),
-			JSON.stringify({
-				type: "message",
-				payload: {
-					content:
-						"Codex ran out of room in the model's context window. Start a new thread or clear earlier history before retrying.",
-				},
-			}),
-			"",
-		].join("\n"),
-	);
-	return transcriptPath;
-}

package/packages/omo-codex/plugin/components/ultrawork/test/directive-source.test.ts

@@ -0,0 +1,16 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+
+describe("codex ultrawork directive source", () => {
+	it("#given bundled directive #when compared to prompts-core codex variant #then bytes match", () => {
+		// given
+		const directive = readFileSync("directive.md", "utf8");
+		const codexPromptUrl = new URL(import.meta.resolve("@oh-my-opencode/prompts-core/prompts/ultrawork/codex.md"));
+
+		// when
+		const codexPrompt = readFileSync(codexPromptUrl, "utf8");
+
+		// then
+		expect(codexPrompt).toBe(directive);
+	});
+});

package/packages/omo-codex/plugin/components/ultrawork/test/package-smoke.test.ts

@@ -10,7 +10,7 @@ type PackageJson = {
 };
 
 describe("codex ultrawork package metadata", () => {
-	it("#given package metadata #when inspected #then hook ships as built TypeScript", () => {
+	it("#given package metadata #when inspected #then hook ships as bundled CLI", () => {
 		// given
 		const packageJson = readPackageJson("package.json");
 		const hooksJson = readJson("hooks/hooks.json");
@@ -25,7 +25,9 @@ describe("codex ultrawork package metadata", () => {
 		expect(packageJson.type).toBe("module");
 		expect(packageJson.packageManager).toBe("npm@11.12.1");
 		expect(packageJson.bin["omo-ultrawork"]).toBe("./dist/cli.js");
-		expect(packageJson.scripts["build"]).toBe("tsc -p tsconfig.build.json");
+		expect(packageJson.scripts["build"]).toBe(
+			"node scripts/sync-directive.mjs && node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && bun build src/cli.ts --target node --format esm --outfile dist/cli.js",
+		);
 		expect(packageJson.scripts["test"]).toBe("vitest --run");
 		expect(packageFiles).toContain("dist");
 		expect(packageFiles).toContain("directive.md");

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

@@ -0,0 +1,5 @@
+import { type UlwLoopScope } from "./paths.js";
+import type { UlwLoopItem, UlwLoopPlan } from "./types.js";
+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

@@ -0,0 +1,79 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { codexGoalMode, isFinalRunCompletionCandidate } from "./goal-status.js";
+import { ulwLoopBriefPath } from "./paths.js";
+import { ULW_LOOP_DIR, ULW_LOOP_GOALS, ULW_LOOP_LEDGER } from "./types.js";
+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 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

@@ -1,4 +1,4 @@
-import { type UlwLoopScope } from "./paths.js";
+import type { UlwLoopScope } from "./paths.js";
 import type { UlwLoopAggregateCompletion, UlwLoopItem, UlwLoopLedgerEntry, UlwLoopPlan } from "./types.js";
 export interface CheckpointUlwLoopArgs {
     readonly goalId: string;

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

@@ -1,81 +1,27 @@
-// biome-ignore-all format: keep checkpoint orchestration below the pure LOC budget.
-import { existsSync } from "node:fs";
+import { existsSync, statSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
-import { formatCodexGoalReconciliation, readCodexGoalSnapshotInput, reconcileCodexGoalSnapshot } from "./codex-goal-snapshot.js";
-import { requireAllCriteriaPass } from "./evidence.js";
-import { codexGoalMode, compatibleCodexObjectives, expectedCodexObjective, isFinalRunCompletionCandidate } from "./goal-status.js";
-import { ulwLoopBriefPath } from "./paths.js";
+import { buildTaskScopedAggregateReconciliationHint, canReconcileActiveFinalTaskScopedAggregateSnapshot, canReconcileCompletedTaskScopedAggregateSnapshot, } from "./checkpoint-reconciliation.js";
+import { formatCodexGoalReconciliation, readCodexGoalSnapshotInput, reconcileCodexGoalSnapshot, } from "./codex-goal-snapshot.js";
+import { requireAllCriteriaPass, requireAllPlanCriteriaPass, requireEssentialCriteriaPass } from "./evidence.js";
+import { codexGoalMode, compatibleCodexObjectives, expectedCodexObjective, isFinalRunCompletionCandidate, } from "./goal-status.js";
 import { appendLedger, readUlwLoopPlan, withUlwLoopMutationLock, writePlan } from "./plan-io.js";
-import { classifyExternalAuthorizationBlocker, clearGoalBlockerFields, sameBlockerOccurrences, validateQualityGate } from "./quality-gate.js";
-import { iso, ULW_LOOP_DIR, ULW_LOOP_GOALS, ULW_LOOP_LEDGER, UlwLoopError } from "./types.js";
-function ulwLoopFail(message, code) { throw new UlwLoopError(message, code); }
-function normalizeObjective(value) { return value.replace(/\s+/g, " ").trim(); }
-function nonEmptyEvidence(value) { const trimmed = value.trim(); return trimmed || ulwLoopFail("Evidence must be a non-empty string.", "ulw_loop_evidence_required"); }
-function findGoal(plan, goalId) { const goal = plan.goals.find((candidate) => candidate.id === goalId); return goal ?? ulwLoopFail(`Unknown ulw-loop id: ${goalId}.`, "ulw_loop_goal_not_found"); }
-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());
+import { classifyExternalAuthorizationBlocker, clearGoalBlockerFields, sameBlockerOccurrences, validateQualityGate, } from "./quality-gate.js";
+import { iso, UlwLoopError } from "./types.js";
+const QUALITY_GATE_FS = { existsSync, statSync };
+function ulwLoopFail(message, code) {
+    throw new UlwLoopError(message, code);
 }
-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;
+function normalizeObjective(value) {
+    return value.replace(/\s+/g, " ").trim();
 }
-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;
-    }
-}
-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);
+function nonEmptyEvidence(value) {
+    const trimmed = value.trim();
+    return trimmed || ulwLoopFail("Evidence must be a non-empty string.", "ulw_loop_evidence_required");
 }
-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 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)}`;
+function findGoal(plan, goalId) {
+    const goal = plan.goals.find((candidate) => candidate.id === goalId);
+    return goal ?? ulwLoopFail(`Unknown ulw-loop id: ${goalId}.`, "ulw_loop_goal_not_found");
 }
 async function readJsonInput(raw, repoRoot) {
     if (raw === undefined || raw.trim() === "")
@@ -133,7 +79,13 @@ function ledgerKind(status, goal, aggregateCompletion) {
     return status === "blocked" ? "goal_blocked" : "goal_failed";
 }
 function buildLedger(now, args, goal, qualityGate, codexGoal, aggregateCompletion) {
-    const entry = { at: now, kind: ledgerKind(args.status, goal, aggregateCompletion), goalId: goal.id, status: goal.status, evidence: args.evidence };
+    const entry = {
+        at: now,
+        kind: ledgerKind(args.status, goal, aggregateCompletion),
+        goalId: goal.id,
+        status: goal.status,
+        evidence: args.evidence,
+    };
     if (codexGoal !== undefined)
         entry.codexGoal = codexGoal;
     if (qualityGate !== undefined)
@@ -150,8 +102,6 @@ export async function checkpointUlwLoop(repoRoot, args, scope) {
     return withUlwLoopMutationLock(repoRoot, scope, async () => {
         const plan = await readUlwLoopPlan(repoRoot, scope);
         const goal = findGoal(plan, args.goalId);
-        if (args.status === "complete")
-            requireAllCriteriaPass(goal);
         const evidence = nonEmptyEvidence(args.evidence);
         const now = iso();
         let aggregateCompletion;
@@ -160,23 +110,45 @@ export async function checkpointUlwLoop(repoRoot, args, scope) {
         if (args.status === "complete") {
             const aggregate = codexGoalMode(plan) === "aggregate";
             const final = isFinalRunCompletionCandidate(plan, goal);
+            if (final) {
+                requireAllCriteriaPass(goal);
+                requireAllPlanCriteriaPass(plan);
+            }
+            else if (aggregate)
+                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 });
+            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 && normalizeObjective(objective) !== normalizeObjective(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 mismatchedTaskObjective = snapshot?.available === true &&
+                    objective !== undefined &&
+                    normalizeObjective(objective) !== normalizeObjective(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 new UlwLoopError(`${formatCodexGoalReconciliation(reconciliation)}${aggregate && snapshot?.status === "complete" && objective !== undefined ? buildTaskScopedAggregateReconciliationHint(goal, final) : ""}`, "ulw_loop_codex_snapshot_mismatch");
-                aggregateCompletion = makeAggregateCompletion(now, evidence, codexGoal);
             }
             if (final)
                 aggregateCompletion = makeAggregateCompletion(now, evidence, codexGoal);
             if (final || aggregateCompletion !== undefined)
-                qualityGate = validateQualityGate(await readJsonInput(args.qualityGateJson, repoRoot));
+                qualityGate = validateQualityGate(await readJsonInput(args.qualityGateJson, repoRoot), {
+                    repoRoot,
+                    fs: QUALITY_GATE_FS,
+                });
             goal.status = "complete";
             goal.completedAt = now;
             goal.evidence = evidence;
@@ -195,6 +167,8 @@ export async function checkpointUlwLoop(repoRoot, args, scope) {
         await writePlan(repoRoot, plan, scope);
         const ledgerEntry = buildLedger(now, args, goal, qualityGate, codexGoal, aggregateCompletion);
         await appendLedger(repoRoot, ledgerEntry, scope);
-        return aggregateCompletion === undefined ? { plan, goal, ledgerEntry } : { plan, goal, ledgerEntry, aggregateCompletion };
+        return aggregateCompletion === undefined
+            ? { plan, goal, ledgerEntry }
+            : { plan, goal, ledgerEntry, aggregateCompletion };
     });
 }