lazycodex-ai 5.0.0-beta.4 → 5.0.0-beta.40

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

@@ -0,0 +1,65 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+export const REVIEWER_ROLES_BY_SURFACE = {
+    lazycodex: {
+        codeReview: "lazycodex-code-reviewer",
+        manualQa: "lazycodex-qa-executor",
+        gateReview: "lazycodex-gate-reviewer",
+    },
+    "omo-senpi": {
+        codeReview: "omo-senpi-code-reviewer",
+        manualQa: "omo-senpi-qa-executor",
+        gateReview: "omo-senpi-gate-reviewer",
+    },
+};
+export const GATE_REVIEWER_AGENT_NAMES = new Set(Object.values(REVIEWER_ROLES_BY_SURFACE).map((roles) => roles.gateReview));
+export const REQUIRED_GATE_SECTIONS_BY_SURFACE = {
+    lazycodex: ["codeReview", "manualQa", "gateReview", "iteration", "criteriaCoverage"],
+    "omo-senpi": ["manualQa", "gateReview", "iteration", "criteriaCoverage"],
+};
+export const GATE_SECTION_BY_ACCEPTOR = {
+    lazycodex: {
+        codeReview: [REVIEWER_ROLES_BY_SURFACE.lazycodex.codeReview],
+        manualQa: [REVIEWER_ROLES_BY_SURFACE.lazycodex.manualQa],
+        gateReview: [REVIEWER_ROLES_BY_SURFACE.lazycodex.gateReview],
+    },
+    "omo-senpi": {
+        manualQa: ["main-session"],
+        gateReview: ["category:deep", "category:unspecified-high", "category:unspecified-low"],
+    },
+};
+export function reviewerRolesFor(surface) {
+    return REVIEWER_ROLES_BY_SURFACE[surface];
+}
+export const SURFACE_MARKER_FILENAME = "surface.json";
+const SURFACE_ENV_KEY = "OMO_AGENT_TOOLKIT_SURFACE";
+function parseSurface(value) {
+    return value === "lazycodex" || value === "omo-senpi" ? value : null;
+}
+// Resolution order: explicit env override (tests, doctor probes) -> staged surface.json marker
+// sitting next to the running bundle -> lazycodex default. The marker is distribution-baked, so a
+// malformed marker falls back to the default instead of crashing checkpoint validation; the env
+// override remains available to force the intended surface on a damaged install.
+export function resolveToolkitSurface(options) {
+    const env = options?.env ?? process.env;
+    const fromEnv = parseSurface(env[SURFACE_ENV_KEY]);
+    if (fromEnv !== null)
+        return fromEnv;
+    const entryDir = options?.entryDir ?? dirname(fileURLToPath(import.meta.url));
+    const markerPath = join(entryDir, SURFACE_MARKER_FILENAME);
+    return readMarkerSurface(markerPath) ?? "lazycodex";
+}
+function readMarkerSurface(markerPath) {
+    try {
+        if (!existsSync(markerPath))
+            return null;
+        const parsed = JSON.parse(readFileSync(markerPath, "utf8"));
+        return parseSurface(parsed["surface"]);
+    }
+    catch (error) {
+        if (error instanceof Error)
+            return null;
+        throw error;
+    }
+}

package/packages/omo-codex/plugin/components/ulw-loop/hooks/hooks.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook user-prompt-submit --with-ultrawork",
 						"timeout": 10,
-						"statusMessage": "(OmO 5.0.0-beta.4) Checking Ulw-Loop Steering"
+						"statusMessage": "(OmO 5.0.0-beta.40) Checking Ulw-Loop Steering"
 					}
 				]
 			}
@@ -20,7 +20,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook pre-tool-use",
 						"timeout": 5,
-						"statusMessage": "(OmO 5.0.0-beta.4) Enforcing Unlimited Ulw-Loop Budget"
+						"statusMessage": "(OmO 5.0.0-beta.40) Enforcing Unlimited Ulw-Loop Budget"
 					}
 				]
 			},
@@ -31,7 +31,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook pre-tool-use-spawn",
 						"timeout": 5,
-						"statusMessage": "(OmO 5.0.0-beta.4) Guarding Ulw-Loop Spawns"
+						"statusMessage": "(OmO 5.0.0-beta.40) Guarding Ulw-Loop Spawns"
 					}
 				]
 			}
@@ -43,7 +43,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook stop",
 						"timeout": 10,
-						"statusMessage": "(OmO 5.0.0-beta.4) Checking Ulw-Loop Resume"
+						"statusMessage": "(OmO 5.0.0-beta.40) Checking Ulw-Loop Resume"
 					}
 				]
 			}

package/packages/omo-codex/plugin/components/ulw-loop/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-ulw-loop",
-	"version": "5.0.0-beta.4",
+	"version": "5.0.0-beta.40",
 	"description": "Codex plugin: durable repo-native multi-goal orchestration with embedded success criteria and observable evidence audit.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",
@@ -47,10 +47,10 @@
 		"check": "tsc --noEmit && biome check . && npm run build"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "2.4.16",
-		"@types/node": "^25.9.3",
-		"typescript": "^6.0.3",
-		"vitest": "^4.1.8"
+		"@biomejs/biome": "2.5.9",
+		"@types/node": "^26.2.0",
+		"typescript": "^7.0.2",
+		"vitest": "^4.1.11"
 	},
 	"engines": {
 		"node": ">=20.0.0"

package/packages/omo-codex/plugin/components/ulw-loop/skills/ulw-loop/SKILL.md

@@ -15,12 +15,13 @@ This skill is intentionally compact. The full workflow lives in `references/full
 
 1. Open `references/full-workflow.md`.
 2. Read through **Bootstrap** (including its tier triage), **Execution Loop**, the **Manual-QA channels** table, and the **Stop Rules** before running any ULW command or recording evidence.
-3. If the task has code edits, tests, QA, or commit work, follow the full workflow's delegation and evidence rules. Tests alone never prove done.
+3. Open `references/define-goal.md` and register the run's goal by it. Goal creation is NEVER skipped: shape the objective and every success criterion by that reference before any implementation.
+4. If the task has code edits, tests, QA, or commit work, follow the full workflow's delegation and evidence rules. Tests alone never prove done.
 
 ## Non-Negotiables
 
 - Use the ulw-loop CLI state under `.omo/ulw-loop`; do not hand-edit goal state.
-- Register goals up front (`omo-agent-toolkit ulw-loop create-goals`, then `create_goal` from the printed handoff) and mirror every atomic step into the live `update_plan` checklist: one ultra-granular step per action, exactly one in_progress, transitions marked the instant they happen.
+- Register goals up front, shaped by `references/define-goal.md` (`omo-agent-toolkit ulw-loop create-goals`, then `create_goal` from the printed handoff), and mirror every atomic step into the live `update_plan` checklist: one ultra-granular step per action, exactly one in_progress, transitions marked the instant they happen.
 - After any compaction or context loss, re-read brief + goals + ledger FIRST plus `omo-agent-toolkit ulw-loop status --json`, then resume; never re-plan from scratch.
 - If `omo-agent-toolkit ulw-loop create-goals` says the existing aggregate is already complete, start unrelated new work with a fresh `--session-id <new-id>` instead of steering or forcing the completed default state. Use `--force` only to intentionally overwrite completed evidence.
 - Every success criterion needs observable evidence from a real surface: a channel (terminal/TUI via the xterm.js web terminal, HTTP, browser, computer-use) or, for CLI- or data-shaped criteria, an auxiliary surface (CLI stdout, DB diff, parsed config dump).

package/packages/omo-codex/plugin/components/ulw-loop/skills/ulw-loop/references/define-goal.md

@@ -0,0 +1,108 @@
+# Define Goal
+
+How to turn a brief into a registered goal the run can be held to. Read this BEFORE calling `create_goal`: the objective you register is the binding contract for the whole run, and the run's quality is capped by the quality of this objective.
+
+A goal is a prompt to the agent that executes it, including future-you after compaction. It earns its tokens the way any prompt does: it carries only what the run cannot re-derive later, the outcome, the proof, the bounds, and the stop state. Everything else is noise that steals attention from the parts that decide completion.
+
+## The quality bar
+
+Before registering, the objective must answer all five:
+
+1. What concrete thing will be TRUE when this is done? An outcome, never an activity.
+2. What evidence will prove it? Commands, validators, artifacts someone can open.
+3. What quantitative or binary threshold defines success?
+4. What scope boundaries matter? What is in, and what is explicitly out.
+5. What should make the agent stop and ask instead of grinding?
+
+An objective that cannot answer one of these is not ready. Repair it (below) before calling the tool.
+
+## Objective anatomy
+
+Write the objective outcome-first, in this order:
+
+1. **Outcome**: one sentence stating what will be true, naming the artifact, system, repo, or user-facing behavior involved.
+2. **Deliverables**: the named surfaces the work lands on (files, endpoints, packages, environments). Use literal paths and names: the executing agent interprets the objective literally and will not infer surfaces you did not name.
+3. **Success criteria**: sized by tier (below), each one a binary observable with its scenario and evidence named upfront.
+4. **Constraints and scope bounds**: Record the user's stated constraints verbatim, including what is explicitly out of scope wherever ambiguity would let the run expand. Where the user was silent on a bound the work forks on, SET it yourself: derive the clearest defensible bound from repo evidence and best practice (stack already in use, compatibility surfaces, scale the code must serve, audience or compliance the repo implies) and record it inside the objective as `assumed: <constraint> — <rationale>, <reversible?>`, binding until the user vetoes it. Unstated bounds do not exist — which is why you write them.
+5. **WHEN TO STOP**: one line, "I'll stop right away when <the exact observable state that ends this run>". This line is binding: the moment it holds, the run delivers and stops. Work past it is a defect, not diligence.
+
+State the motivation when it changes execution ("p95 matters because the checkout SLA is 300ms") and omit it when it does not. Positive statements beat prohibitions: "verify against staging" carries more signal than "do not touch production".
+
+## Success criteria construction
+
+Count by tier, mirroring the run's tier triage:
+
+- LIGHT (known pattern, no open design decisions): 1-2 criteria, happy path plus the riskiest edge.
+- HEAVY (new module or abstraction, auth or security, external integration, schema or migration, concurrency, cross-domain refactor, or the user demanded care): 3+ criteria covering happy path, edge (boundary, empty, malformed, concurrent), adjacent-surface regression named by file and function, and the adversarial risk the change actually creates.
+
+Every criterion carries, at definition time, not after the work:
+
+- a binary pass condition ("returns 200 and the body matches the schema", never "works correctly");
+- the exact scenario: the literal command, request, page action, or payload that will prove it;
+- the evidence artifact it will capture: transcript, status plus body, screenshot path, diff, parsed dump;
+- the failing-first proof (test id or scenario) that will be captured RED before implementation.
+
+A criterion that cannot fail is not a criterion. If no input could make the scenario fail, it measures nothing; rewrite it until failure is possible.
+
+## Make it quantitative
+
+Prefer numbers that represent real success over decorative precision. A threshold nobody would act on differently is noise.
+
+| Domain | Quantify as |
+| --- | --- |
+| Bug fix | reproduction first, fix second: the failing case captured RED, then the same validator green |
+| Tests | the exact command and required pass condition, plus run count for flake-sensitive suites |
+| Performance | metric, target threshold, measurement method, and run count ("p95 under 250ms across 3 consecutive local runs") |
+| Quality work | the observable acceptance bar: lint, typecheck, and test pass; reviewed examples; a user-approved artifact |
+| Research | the decision the research must enable, the sources or systems in scope, and the evidence standard per claim |
+| Operations | healthy state, monitoring window, failure threshold, and the rollback or escalation trigger |
+
+## Repair weak goals
+
+Reject pure activity objectives: "make progress", "keep investigating", "improve things", "work on X". They cannot fail, so they cannot finish.
+
+Rewrite vague goals into measurable ones when local context makes the rewrite safe. Ask ONE narrow question only when the missing detail is an OWNER-DECISION — irreversible, destructive, safety-critical, or a cross-cutting product choice (real budget or spend, public surface, external dependency, data shape, target audience) — that changes the intended outcome or its validation, shaped around the missing validator or bound:
+
+- "What metric defines success here: latency, cost, accuracy, or user-visible behavior?"
+- "Which environment do I verify against: local, staging, or production?"
+- "What is the minimum evidence you want before this goal is marked complete?"
+
+Every other missing constraint follows Objective anatomy #4: adopt the clearest defensible default, state it in the objective as `assumed:`, and let the user veto.
+
+When the user cannot provide a metric, propose the most honest binary validator available and proceed with it stated in the objective.
+
+Weak: "Make checkout faster."
+Repaired: "Reduce checkout API p95 below 250ms on the documented slow path with the smallest safe server-side change; prove it with `npm run test:checkout` green plus the local latency benchmark showing p95 under 250ms across 3 consecutive runs; out of scope: client-side changes and new caching layers."
+
+Weak: "Keep investigating the PR comments."
+Repaired: "Resolve every open change-requesting review comment on PR 123 touching only the affected auth files and their tests; prove it with the targeted auth test command green plus `gh pr view 123` showing zero unresolved change-request threads."
+
+## Registration protocol
+
+1. Call `get_goal` first, then act by state:
+
+| get_goal shows | Action |
+| --- | --- |
+| no active goal | Register with `create_goal`, passing exactly `objective`. Never include lifecycle fields such as `status`; never register a goal in prose, a notepad, or a plan instead of the tool. |
+| an active goal matching this intent | Continue it. Never register a duplicate. |
+| an active goal conflicting with this intent | Stop and surface the conflict; the user decides whether to finish it, complete it, or branch. |
+
+2. Goals are unlimited. Never invent a numeric budget, token limit, or deadline the user did not state — that ban covers run quotas; the `assumed:` work constraints from Objective anatomy #4 are different and required.
+3. In a ulw-loop run, the loop CLI owns per-goal state (`.omo/ulw-loop/goals.json`): `create_goal` registers the aggregate objective from the printed handoff, and this reference shapes both that objective and every goal's `successCriteria` at `create-goals` time.
+
+## Completion honesty
+
+- Report `update_goal` complete only after auditing every criterion against evidence captured in this run. A green suite is supporting evidence, never completion proof by itself.
+- Waiting is not blocked: while a monitor, background child, or scheduled continuation can wake the run, end the turn and let it fire. Blocked requires a true impasse: no live resumption channel, and the same block recurring across consecutive turns.
+- The moment the WHEN TO STOP line holds with evidence in hand, deliver and stop.
+
+## Anti-patterns
+
+| Anti-pattern | Why it fails | Instead |
+| --- | --- | --- |
+| Activity objective ("investigate X") | Cannot fail, so cannot finish; the run wanders | Name the outcome the activity must produce and its evidence |
+| Criteria added after implementation | The contract bent to fit the work; nothing was proven | Write criteria and scenarios at registration, before any edit |
+| Decorative precision ("99.97% uptime" nobody measures) | A threshold no validator checks is noise wearing a suit | Only thresholds a named validator will actually check |
+| Padded objective (role prose, restated context, filler) | Every extra token competes with the criteria for attention | Outcome, deliverables, criteria, bounds, stop line; nothing else |
+| Goal registered in prose or a notepad | Nothing binds the run; completion becomes a vibe | `create_goal` with the objective, every time the tool exists |
+| Duplicate goal for the same intent | Two contracts, neither authoritative | Continue the active goal or surface the conflict |

package/packages/omo-codex/plugin/components/ulw-loop/skills/ulw-loop/references/full-workflow.md

@@ -121,6 +121,7 @@ only when deliberately overwriting completed evidence.
 Write state through the CLI path. Do not hand-edit state files.
 
 ### 2. Refine success criteria + a Prometheus-grade QA and parallelism plan per goal
+Shape every goal's objective and `successCriteria` by `references/define-goal.md`: its quality bar, objective anatomy, and criterion construction govern this step. Where the brief is silent on a constraint the work forks on, derive the default per that reference, record it via `annotate_ledger` (`--evidence` naming the repo fact, `--rationale` the default plus reversibility), and surface the assumed list in the first user-visible report so a wrong default is a one-line veto, not a finished run.
 Gather context BEFORE planning with parallel `explorer` / `librarian` workers plus your own read-only tools.
 First survey available skills: read every loosely-relevant skill's description, deliberately choose which this work uses, and prefer applying genuinely-relevant skills over working raw.
 Then run tier triage per goal — rigor (LIGHT/HEAVY below) and shape (`delivery` default, or `research` when the deliverable is a cited answer, not an artifact) — and record both in an `annotate_ledger` steering entry. Default is LIGHT — a narrow change inside existing layers. Take HEAVY only on a fact you can point to: a new module / abstraction / domain model; auth, security, or session; an external integration; a DB schema or migration; concurrency, transaction boundaries, or cache invalidation; a cross-domain refactor; or the user signaled care or demanded review. When unsure, take HEAVY; upgrade the moment a HEAVY fact surfaces, never downgrade mid-run.
@@ -178,6 +179,24 @@ Loop per goal. Cap at 5 cycles per goal. Cap identical same-criterion failures a
 4. If blocked or failed, checkpoint with `--status blocked` or `--status failed` and include diagnosis evidence.
 5. If this is the final goal, run the final quality gate first and pass `--quality-gate-json`.
 
+## Exact final-story sequence
+For the final story, follow this exact checkpoint sequence:
+
+```sh
+omo-agent-toolkit ulw-loop status --json
+# Read nextActions and currentAttemptDir.
+omo-agent-toolkit ulw-loop record-evidence --goal-id <g> --criterion-id <c> --status pass --evidence "..."
+# Repeat record-evidence once per criterion.
+# Then use the harness update_goal tool with status complete.
+omo-agent-toolkit ulw-loop checkpoint --goal-id <g> --print-template --json
+# Fill the printed template: replace every placeholder and use real artifact paths under currentAttemptDir.
+# codex-goal-json.goal.objective must equal the plan's codexObjective verbatim.
+omo-agent-toolkit ulw-loop checkpoint --goal-id <g> --status complete --evidence "..." --codex-goal-json <path> --quality-gate-json <path>
+omo-agent-toolkit ulw-loop complete-goals
+```
+
+The lazycodex gate uses all five sections shown in the sample below, including `codeReview`.
+
 ## Final Quality Gate
 Trigger only for the final aggregate goal after every criterion in every goal is `pass`.
 1. Run targeted verification for changed behavior.
@@ -191,12 +210,14 @@ Trigger only for the final aggregate goal after every criterion in every goal is
 ```sh
 omo-agent-toolkit ulw-loop checkpoint --goal-id <id> --status complete --evidence "<e2e evidence + manual QA notes>" --codex-goal-json <snapshot> --quality-gate-json <json-or-path> --json
 ```
+`--quality-gate-json` shape. In `manualQa.artifactRefs`, `kind` must be one of `cli-transcript`, `log`, `screenshot`, `image`, `http-dump`, or `data-diff`; review and QA reports belong in `codeReview.reportPath` or `gateReview.reportPath`, not `artifactRefs`. `surfaceEvidence.surface` must be one of `cli`, `http`, `tmux`, `browser`, `gui`, or `data`. Compatibility is `cli`/`tmux` -> `cli-transcript`/`log`, `http` -> `http-dump`, `browser`/`gui` -> `screenshot`/`image`, and `data` -> `data-diff`.
+
 `--quality-gate-json` shape:
 ```json
 {
   "codeReview":{"by":"lazycodex-code-reviewer","recommendation":"APPROVE","codeQualityStatus":"CLEAR","reportPath":"test/fixtures/artifacts/code-review.md","evidence":"Diff review passed.","blockers":[]},
   "manualQa":{"by":"lazycodex-qa-executor","status":"passed","evidence":"CLI and data surfaces passed.","surfaceEvidence":[{"id":"surface-cli-pass","criterionRef":"C1","surface":"cli","invocation":"omo-agent-toolkit ulw-loop checkpoint --quality-gate-json sample-quality-gate.json --json","verdict":"passed","artifactRefs":["artifact-cli-pass"]},{"id":"surface-data-pass","criterionRef":"C2","surface":"data","invocation":"diff -u before-ledger.json after-ledger.json","verdict":"passed","artifactRefs":["artifact-data-diff"]}],"adversarialCases":[{"id":"adv-malformed-input","criterionRef":"C3","scenario":"malformed gate input omits manual QA evidence","expectedBehavior":"validator rejects ULW_LOOP_QUALITY_GATE_INVALID","verdict":"passed","artifactRefs":["artifact-cli-reject"]}],"artifactRefs":[{"id":"artifact-cli-pass","kind":"cli-transcript","description":"CLI pass artifact.","path":"test/fixtures/artifacts/cli-pass.txt"},{"id":"artifact-cli-reject","kind":"log","description":"Reject log artifact.","path":"test/fixtures/artifacts/rejection.txt"},{"id":"artifact-data-diff","kind":"data-diff","description":"Data diff artifact.","path":"test/fixtures/artifacts/data-diff.txt"}]},
-  "gateReview":{"by":"lazycodex-gate-reviewer","recommendation":"APPROVE","reportPath":"test/fixtures/artifacts/gate-review.md","evidence":"Gate review passed.","blockers":[]},
+  "gateReview":{"by":"lazycodex-gate-reviewer","recommendation":"APPROVE","reportPath":"test/fixtures/artifacts/gate-review.md","evidence":"Gate review passed.","blockers":[],"notes":[]},
   "iteration":{"fullRerun":true,"status":"passed","rerunCommands":["bunx vitest run packages/omo-codex/plugin/components/ulw-loop/test/quality-gate-doc.test.ts"],"evidence":"Focused rerun passed."},
   "criteriaCoverage":{"totalCriteria":3,"passCount":3,"originalIntent":"User wanted artifact-backed completion.","desiredOutcome":"Behavior ships with review and QA evidence.","userOutcomeReview":"Result matches brief and goals.","adversarialClassesCovered":["malformed_input","stale_state"]}
 }

package/packages/omo-codex/plugin/components/ulw-loop/src/checkpoint-codex-validation.ts

@@ -0,0 +1,81 @@
+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 type { UlwLoopScope } from "./paths.js";
+import type { UlwLoopItem, UlwLoopPlan } from "./types.js";
+import { UlwLoopError } from "./types.js";
+
+function normalizeObjective(value: string): string {
+	return value.replace(/\s+/g, " ").trim();
+}
+
+export async function validateCheckpointCodexGoal(input: {
+	readonly repoRoot: string;
+	readonly plan: UlwLoopPlan;
+	readonly goal: UlwLoopItem;
+	readonly raw: string | undefined;
+	readonly evidence: string;
+	readonly scope?: UlwLoopScope;
+}): Promise<unknown> {
+	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 &&
+		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 },
+	});
+}
+
+export function combineCheckpointValidationErrors(codexError: UlwLoopError, gateError: UlwLoopError): UlwLoopError {
+	return new UlwLoopError(`${codexError.message}\n${gateError.message}`, "ULW_LOOP_QUALITY_GATE_INVALID", {
+		details: { ...(codexError.details ?? {}), ...(gateError.details ?? {}) },
+	});
+}

package/packages/omo-codex/plugin/components/ulw-loop/src/checkpoint-continuation.ts

@@ -1,4 +1,5 @@
 import { type CheckpointUlwLoopArgs, type CheckpointUlwLoopResult, checkpointUlwLoop } from "./checkpoint.js";
+import { checkpointTemplate } from "./checkpoint-template.js";
 import { hasFlag, parseCodexGoalJson, readValue } from "./cli-arg-parser.js";
 import { blockedDecisionHandoff, printJson } from "./cli-output.js";
 import { buildCodexGoalInstruction, type UlwLoopGoalInstruction } from "./codex-goal-instruction.js";
@@ -32,6 +33,12 @@ export async function checkpoint(
 	json: boolean,
 	scope?: UlwLoopScope,
 ): Promise<number> {
+	if (hasFlag(argv, "--print-template")) {
+		const template = await checkpointTemplate(repoRoot, scope, readValue(argv, "--goal-id"));
+		if (json) printJson({ ok: true, ...template });
+		else printJson(template);
+		return 0;
+	}
 	const goalId = required(argv, "--goal-id");
 	const statusValue = checkpointStatus(required(argv, "--status"));
 	const evidence = required(argv, "--evidence");

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

@@ -1,10 +1,40 @@
 import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 
+import type { CodexGoalReconciliation, CodexGoalSnapshot } from "./codex-goal-snapshot.js";
+import { codexGoalMismatchRecovery, formatCodexGoalReconciliation } from "./codex-goal-snapshot.js";
 import { codexGoalMode, isFinalRunCompletionCandidate } from "./goal-status.js";
 import { type UlwLoopScope, ulwLoopBriefPath } from "./paths.js";
 import type { UlwLoopItem, UlwLoopPlan } from "./types.js";
-import { ULW_LOOP_DIR, ULW_LOOP_GOALS, ULW_LOOP_LEDGER } from "./types.js";
+import { ULW_LOOP_DIR, ULW_LOOP_GOALS, ULW_LOOP_LEDGER, 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 function combineCheckpointValidationErrors(codexError: UlwLoopError, gateError: UlwLoopError): UlwLoopError {
+	return new UlwLoopError(`${codexError.message}\n${gateError.message}`, "ULW_LOOP_QUALITY_GATE_INVALID", {
+		details: { ...(codexError.details ?? {}), ...(gateError.details ?? {}) },
+	});
+}
+
+export function codexSnapshotMismatchError(input: CodexSnapshotMismatchInput): UlwLoopError {
+	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: string): string {
 	return value.replace(/\s+/g, " ").trim();

package/packages/omo-codex/plugin/components/ulw-loop/src/checkpoint-template.ts

@@ -0,0 +1,134 @@
+import { type UlwLoopScope, ulwLoopAttemptEvidenceDir } from "./paths.js";
+import { readUlwLoopPlan } from "./plan-io.js";
+import { resolveToolkitSurface, type UlwLoopToolkitSurface } from "./surface.js";
+import type { UlwLoopPlan } from "./types.js";
+import { UlwLoopError } from "./types.js";
+
+export interface CheckpointTemplate {
+	readonly qualityGateTemplate: Record<string, unknown>;
+	readonly codexGoalTemplate: Record<string, unknown>;
+	readonly attemptDir?: string;
+	readonly guidance?: string;
+}
+
+function artifactPath(base: string, name: string): string {
+	return `${base}/${name}`;
+}
+
+function gateTemplate(surface: UlwLoopToolkitSurface, base: string): Record<string, unknown> {
+	const artifacts = [
+		{
+			id: "artifact-cli",
+			kind: "cli-transcript",
+			description: "<replace:artifact description>",
+			path: artifactPath(base, "cli-transcript.txt"),
+		},
+		{
+			id: "artifact-data",
+			kind: "data-diff",
+			description: "<replace:artifact description>",
+			path: artifactPath(base, "data-diff.txt"),
+		},
+	];
+	const manualQa = {
+		by: surface === "omo-senpi" ? "main-session" : "lazycodex-qa-executor",
+		status: "passed",
+		evidence: "<replace:manual QA evidence>",
+		surfaceEvidence: [
+			{
+				id: "surface-cli",
+				criterionRef: "<replace:criterion id>",
+				surface: "cli",
+				invocation: "<replace:command>",
+				verdict: "passed",
+				artifactRefs: ["artifact-cli"],
+			},
+			{
+				id: "surface-data",
+				criterionRef: "<replace:criterion id>",
+				surface: "data",
+				invocation: "<replace:command>",
+				verdict: "passed",
+				artifactRefs: ["artifact-data"],
+			},
+		],
+		adversarialCases: [
+			{
+				id: "<replace:adversarial case id>",
+				criterionRef: "<replace:criterion id>",
+				scenario: "<replace:scenario>",
+				expectedBehavior: "<replace:expected behavior>",
+				verdict: "not_applicable",
+				reason: "<replace:reason>",
+				artifactRefs: ["artifact-cli"],
+			},
+		],
+		artifactRefs: artifacts,
+	};
+	const common = {
+		manualQa,
+		gateReview: {
+			by: surface === "omo-senpi" ? "category:deep" : "lazycodex-gate-reviewer",
+			recommendation: "APPROVE",
+			reportPath: artifactPath(base, "gate-review.md"),
+			evidence: "<replace:gate review evidence>",
+			blockers: [],
+			notes: [],
+		},
+		iteration: {
+			fullRerun: true,
+			status: "passed",
+			rerunCommands: ["<replace:verification command>"],
+			evidence: "<replace:iteration evidence>",
+		},
+		criteriaCoverage: {
+			totalCriteria: 0,
+			passCount: 0,
+			originalIntent: "<replace:original intent>",
+			desiredOutcome: "<replace:desired outcome>",
+			userOutcomeReview: "<replace:user outcome review>",
+			adversarialClassesCovered: ["<replace:adversarial class>"],
+		},
+	};
+	if (surface === "omo-senpi") return common;
+	return {
+		codeReview: {
+			by: "lazycodex-code-reviewer",
+			recommendation: "APPROVE",
+			codeQualityStatus: "CLEAR",
+			reportPath: artifactPath(base, "code-review.md"),
+			evidence: "<replace:code review evidence>",
+			blockers: [],
+		},
+		...common,
+	};
+}
+
+export async function checkpointTemplate(
+	repoRoot: string,
+	scope?: UlwLoopScope,
+	goalId?: string,
+): Promise<CheckpointTemplate> {
+	const plan: UlwLoopPlan = await readUlwLoopPlan(repoRoot, scope);
+	const targetId = goalId ?? plan.activeGoalId;
+	const active = plan.goals.find((goal) => goal.id === targetId);
+	if (goalId !== undefined && active === undefined)
+		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" },
+		},
+		guidance,
+		...(hasAttempt ? { attemptDir } : {}),
+	};
+}